@arex95/vue-core 1.1.43 → 3.0.0

package/dist/types/ExtendedQueryOptions.d.ts

@@ -1,6 +1,16 @@
 import { UseQueryOptions } from '@tanstack/vue-query';
+/**
+ * Extends the standard `UseQueryOptions` from Vue Query with additional properties
+ * to control server-side execution and provide a custom query key.
+ */
 export type ExtendedQueryOptions = {
+    /** The standard Vue Query options object. */
     options?: UseQueryOptions;
+    /**
+     * If `false`, the query will not be executed on the server during server-side rendering (SSR).
+     * @default true
+     */
     server?: boolean;
+    /** An optional custom query key to override the default key generation. */
     queryKey?: string;
 };

package/dist/types/Fetcher.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Configuration object for making HTTP requests.
+ * This interface is agnostic of any specific HTTP library.
+ */
+export interface FetcherConfig {
+    /** HTTP method (GET, POST, PUT, DELETE, PATCH, etc.) */
+    method: string;
+    /** URL endpoint (can be relative or absolute) */
+    url: string;
+    /** Query parameters (will be converted to query string) */
+    params?: Record<string, any>;
+    /** Request body data */
+    data?: any;
+    /** HTTP headers */
+    headers?: Record<string, string>;
+}
+/**
+ * A generic fetcher function that accepts FetcherConfig and returns a Promise.
+ * This function is agnostic of any specific HTTP library (axios, ofetch, fetch, etc.).
+ *
+ * @param config - The request configuration
+ * @returns A promise that resolves with the response data
+ */
+export type Fetcher = (config: FetcherConfig) => Promise<any>;

package/dist/types/RestStdOptions.d.ts

@@ -0,0 +1,62 @@
+export interface GetAllOptions<TParams extends Record<string, unknown> = Record<string, unknown>> {
+    params?: TParams;
+    options?: Record<string, unknown>;
+    url?: string;
+}
+export interface GetOneOptions<TParams extends Record<string, unknown> = Record<string, unknown>> {
+    id: string | number;
+    params?: TParams;
+    options?: Record<string, unknown>;
+    url?: string;
+}
+export interface CreateOptions<TData = unknown> {
+    data: TData;
+    options?: Record<string, unknown>;
+    url?: string;
+}
+export interface UpdateOptions<TData = unknown> {
+    id: string | number;
+    data: TData;
+    options?: Record<string, unknown>;
+    url?: string;
+}
+export interface PatchOptions<TData = unknown> {
+    id: string | number;
+    data: Partial<TData>;
+    options?: Record<string, unknown>;
+    url?: string;
+}
+export interface DeleteOptions {
+    id: string | number;
+    options?: Record<string, unknown>;
+    url?: string;
+}
+export interface BulkCreateOptions<TData = unknown> {
+    data: TData[];
+    options?: Record<string, unknown>;
+    url?: string;
+}
+export interface BulkUpdateOptions<TData = unknown> {
+    data: TData[];
+    options?: Record<string, unknown>;
+    url?: string;
+}
+export interface BulkDeleteOptions {
+    ids: (string | number)[];
+    options?: Record<string, unknown>;
+    url?: string;
+}
+export interface UpsertOptions<TData = unknown> {
+    data: TData & {
+        id?: string | number;
+    };
+    options?: Record<string, unknown>;
+    url?: string;
+}
+export interface CustomRequestOptions<TParams extends Record<string, unknown> = Record<string, unknown>, TData = unknown> {
+    method: string;
+    url: string;
+    params?: TParams;
+    data?: TData;
+    options?: Record<string, unknown>;
+}

package/dist/types/SessionConfig.d.ts

@@ -1,13 +1,37 @@
-export type LocationPreference = "local" | "session" | "any";
+/**
+ * Defines the possible storage locations for session data.
+ * - `local`: `localStorage`, persists after the browser is closed.
+ * - `session`: `sessionStorage`, cleared when the browser is closed.
+ * - `cookie`: Cookies with encryption and security options (Secure, SameSite).
+ * - `any`: Used for retrieval operations to check all storage locations (session, local, cookie).
+ */
+export type LocationPreference = "local" | "session" | "cookie" | "any";
+/**
+ * Defines the structure of the session configuration object that is stored and retrieved.
+ */
 export type SessionConfig = {
+    /** The unique identifier for the current session. */
     SESSION_ID: string;
+    /** The chosen storage location for the session data. */
     PERSISTENCE: LocationPreference;
 };
+/**
+ * Represents the internal, mutable state of the session configuration.
+ * This is used within the session management module to track the current settings.
+ */
 export interface InternalSessionState {
+    /** The current session ID. */
     sessionId: string;
+    /** The current persistence preference. */
     persistencePreference: LocationPreference;
 }
+/**
+ * Defines the structure for the object used to configure the session.
+ * All properties are optional, allowing for partial updates to the session configuration.
+ */
 export interface SessionConfigObject {
+    /** An optional new session ID. */
     sessionId?: string;
+    /** An optional new persistence preference. */
     persistencePreference?: LocationPreference;
 }

package/dist/types/TokenConfig.d.ts

@@ -1,4 +1,11 @@
+/**
+ * Defines the structure for the token configuration object, which specifies the storage keys
+ * for the access and refresh tokens. The properties are read-only to ensure they are not
+ * accidentally modified at runtime.
+ */
 export type TokensConfig = {
+    /** The key used to store the access token in `localStorage` or `sessionStorage`. */
     readonly ACCESS_TOKEN: string;
+    /** The key used to store the refresh token in `localStorage` or `sessionStorage`. */
     readonly REFRESH_TOKEN: string;
 };

package/dist/types/TokenValidationResult.d.ts

@@ -1,4 +1,11 @@
+/**
+ * Represents the successful result of a token extraction and validation operation.
+ * This type is used to ensure that both the access and refresh tokens are returned
+ * as strings after being validated.
+ */
 export type TokenValidationResult = {
+    /** The validated access token. */
     accessToken: string;
+    /** The validated refresh token. */
     refreshToken: string;
 };

package/dist/types/index.d.ts

@@ -10,3 +10,5 @@ export * from './ArexVueCoreOptions';
 export * from './AppKeyConfig';
 export * from './AxiosServiceOptions';
 export * from './TokenValidationResult';
+export * from './Fetcher';
+export * from './RestStdOptions';

package/dist/utils/browser.d.ts

@@ -1,10 +1,11 @@
 /**
- * Opens a new window with the specified URL and options.
- * @param {string} url The URL to open.
- * @param {Object} [opt] Options for the new window.
- * @param {string} [opt.target='__blank'] The target window name.
- * @param {boolean} [opt.noopener=true] Whether to add 'noopener' attribute.
- * @param {boolean} [opt.noreferrer=true] Whether to add 'noreferrer' attribute.
+ * Opens a new browser window or tab with a specified URL, providing options for the target and security attributes.
+ *
+ * @param {string} url - The URL to open in the new window.
+ * @param {object} [opt] - Optional configuration for the new window.
+ * @param {string} [opt.target='_blank'] - The target attribute for the link, specifying where to open the content (e.g., '_blank', '_self').
+ * @param {boolean} [opt.noopener=true] - If `true`, adds `noopener` to the window features to prevent the new window from accessing the original window's object.
+ * @param {boolean} [opt.noreferrer=true] - If `true`, adds `noreferrer` to prevent the browser from sending the `Referer` HTTP header.
  */
 export declare function openWindow(url: string, opt?: {
     target?: string;
@@ -12,19 +13,24 @@ export declare function openWindow(url: string, opt?: {
     noreferrer?: boolean;
 }): void;
 /**
- * Copies text to the clipboard.
- * @param {string} text The text to copy.
- * @returns {Promise<void>} A promise that resolves when the text has been copied.
+ * Asynchronously copies a given string to the user's clipboard. It uses the modern `navigator.clipboard` API
+ * with a fallback to the deprecated `document.execCommand` for older browsers.
+ *
+ * @param {string} text - The string to be copied to the clipboard.
+ * @returns {Promise<void>} A promise that resolves when the text has been successfully copied.
  */
 export declare function copyToClipboard(text: string): Promise<void>;
 /**
- * Scrolls the window to the top smoothly.
- * @param {number} [duration=300] Duration of the scroll animation in milliseconds.
+ * Smoothly scrolls the window to the top of the page using a `requestAnimationFrame` loop
+ * for a fluid animation.
+ *
+ * @param {number} [duration=300] - The total duration of the scroll animation in milliseconds.
  */
 export declare function scrollToTop(duration?: number): void;
 /**
- * Gets the value of a query parameter from the URL.
- * @param {string} paramName The name of the query parameter.
- * @returns {string | null} The value of the query parameter, or null if it does not exist.
+ * Retrieves the value of a specified query parameter from the current URL's search string.
+ *
+ * @param {string} paramName - The name of the query parameter to retrieve.
+ * @returns {string | null} The value of the query parameter, or `null` if the parameter is not present in the URL.
  */
 export declare function getQueryParam(paramName: string): string | null;

package/dist/utils/dates.d.ts

@@ -1,71 +1,84 @@
 /**
- * Parses a date string into a Date object.
- * @param {string} dateString The date string in 'YYYY-MM-DD' format.
- * @returns {Date | null} The parsed Date object or null if the format is invalid.
+ * Parses a date string in the format 'YYYY-MM-DD' and returns a `Date` object.
+ * It includes validation to ensure the parsed date is a valid calendar date.
+ *
+ * @param {string} dateString - The date string to parse.
+ * @returns {Date | null} A `Date` object if the string is a valid date, otherwise `null`.
  */
 export declare function parseDate(dateString: string): Date | null;
 /**
- * Formats a Date object into a string.
- * @param {Date} date The date to format.
- * @param {string} format The format string (e.g., 'YYYY-MM-DD').
+ * Formats a `Date` object into a custom string format.
+ * Supported format specifiers: YYYY, MM, DD, HH, mm, ss.
+ *
+ * @param {Date} date - The `Date` object to format.
+ * @param {string} format - The desired string format (e.g., 'YYYY-MM-DD HH:mm:ss').
  * @returns {string} The formatted date string.
  */
 export declare function formatDate(date: Date, format: string): string;
 /**
- * Calculates the number of days between two dates.
- * @param {Date} startDate The start date.
- * @param {Date} endDate The end date.
+ * Calculates the total number of full days between two dates.
+ *
+ * @param {Date} startDate - The starting date.
+ * @param {Date} endDate - The ending date.
  * @returns {number} The number of days between the two dates.
  */
 export declare function daysBetween(startDate: Date, endDate: Date): number;
 /**
- * Adds a specified number of days to a date.
- * @param {Date} date The date to modify.
- * @param {number} days The number of days to add.
- * @returns {Date} The new date with days added.
+ * Adds a specified number of days to a given date.
+ *
+ * @param {Date} date - The original date.
+ * @param {number} days - The number of days to add (can be negative to subtract).
+ * @returns {Date} A new `Date` object representing the resulting date.
  */
 export declare function addDays(date: Date, days: number): Date;
 /**
- * Subtracts a specified number of days from a date.
- * @param {Date} date The date to modify.
- * @param {number} days The number of days to subtract.
- * @returns {Date} The new date with days subtracted.
+ * Subtracts a specified number of days from a given date.
+ *
+ * @param {Date} date - The original date.
+ * @param {number} days - The number of days to subtract.
+ * @returns {Date} A new `Date` object representing the resulting date.
  */
 export declare function subtractDays(date: Date, days: number): Date;
 /**
- * Determines if a year is a leap year.
- * @param {number} year The year to check.
- * @returns {boolean} True if the year is a leap year, false otherwise.
+ * Determines whether a given year is a leap year according to the Gregorian calendar rules.
+ *
+ * @param {number} year - The year to check.
+ * @returns {boolean} `true` if the year is a leap year, otherwise `false`.
  */
 export declare function isLeapYear(year: number): boolean;
 /**
- * Gets the first day of the month for a given date.
- * @param {Date} date The date to use.
- * @returns {Date} The first day of the month.
+ * Returns a new `Date` object set to the first day of the month for a given date.
+ *
+ * @param {Date} date - The date from which to determine the month and year.
+ * @returns {Date} A `Date` object representing the start of the month.
  */
 export declare function getStartOfMonth(date: Date): Date;
 /**
- * Gets the last day of the month for a given date.
- * @param {Date} date The date to use.
- * @returns {Date} The last day of the month.
+ * Returns a new `Date` object set to the last day of the month for a given date.
+ *
+ * @param {Date} date - The date from which to determine the month and year.
+ * @returns {Date} A `Date` object representing the end of the month.
  */
 export declare function getEndOfMonth(date: Date): Date;
 /**
- * Calculates age from a given birth date.
- * @param {Date} birthDate The birth date.
+ * Calculates the current age in years based on a given birth date.
+ *
+ * @param {Date} birthDate - The date of birth.
  * @returns {number} The calculated age.
  */
 export declare function calculateAge(birthDate: Date): number;
 /**
- * Calculates the number of days until the next birthday.
- * @param {Date} birthDate The birth date.
+ * Calculates the number of days from the current date until the next birthday.
+ *
+ * @param {Date} birthDate - The date of birth.
  * @returns {number} The number of days until the next birthday.
  */
 export declare function daysToNextBirthday(birthDate: Date): number;
 /**
- * Calculates the age at a specific date.
- * @param {Date} birthDate The birth date.
- * @param {Date} atDate The date to calculate the age at.
- * @returns {number} The calculated age.
+ * Calculates the age of a person on a specific date in the past or future.
+ *
+ * @param {Date} birthDate - The date of birth.
+ * @param {Date} atDate - The target date for which to calculate the age.
+ * @returns {number} The age on the specified date.
  */
 export declare function ageAtDate(birthDate: Date, atDate: Date): number;

package/dist/utils/debounces.d.ts

@@ -1,57 +1,79 @@
 /**
- * Creates a debounced asynchronous validator function.
+ * Creates a debounced version of an asynchronous validator function. This is useful for scenarios
+ * like form input validation where you want to delay validation until the user has stopped typing.
  *
- * @param validator - The async validator function to debounce.
- * @param delay - The debounce delay in milliseconds.
- * @returns A debounced version of the validator function.
+ * @param validator - The asynchronous validator function to be debounced. It receives the value to validate and a `debounce` function.
+ * @param {number} delay - The debounce delay in milliseconds.
+ * @returns A new function that takes a value and returns a promise that resolves or rejects based on the debounced validation.
  */
 export declare function debounceAsyncValidator(validator: (value: any, debounce: () => Promise<void>) => Promise<void>, delay: number): (value: any) => Promise<void>;
 /**
- * Creates a debounced version of an asynchronous function.
- * @param {Function} func The asynchronous function to debounce.
- * @param {number} wait The number of milliseconds to wait before invoking the function.
- * @returns {Function} The debounced function.
+ * Creates a debounced version of an asynchronous function. The debounced function will only
+ * resolve the promise of the last invocation within the `wait` period.
+ *
+ * @template T - The type of the asynchronous function.
+ * @param {T} func - The asynchronous function to debounce.
+ * @param {number} wait - The debounce delay in milliseconds.
+ * @returns A new debounced asynchronous function.
  */
 export declare function debounceAsync<T extends (...args: any[]) => Promise<any>>(func: T, wait: number): (...args: Parameters<T>) => Promise<ReturnType<T>>;
 /**
- * Creates a debounced asynchronous function that executes immediately on the first call.
- * @param {Function} func The asynchronous function to debounce.
- * @param {number} wait The number of milliseconds to wait before invoking the function.
- * @returns {Function} The debounced function with immediate execution on the first call.
+ * Creates a debounced version of an asynchronous function that executes immediately on the first call
+ * and then waits for the specified delay before allowing the next execution.
+ *
+ * @template T - The type of the asynchronous function.
+ * @param {T} func - The asynchronous function to debounce.
+ * @param {number} wait - The cooldown period in milliseconds after an immediate execution.
+ * @returns A new debounced asynchronous function that executes on the leading edge.
  */
 export declare function debounceAsyncWithImmediate<T extends (...args: any[]) => Promise<any>>(func: T, wait: number): (...args: Parameters<T>) => Promise<ReturnType<T>>;
 /**
- * Creates a debounced version of a function that executes on the leading edge.
- * @param {Function} func The function to debounce.
- * @param {number} wait The number of milliseconds to wait before invoking the function.
- * @returns {Function} The debounced function.
+ * Creates a debounced function that invokes `func` on the leading edge of the `wait` timeout.
+ * Subsequent calls within the `wait` period are ignored.
+ *
+ * @template T - The type of the function.
+ * @param {T} func - The function to debounce.
+ * @param {number} wait - The debounce delay in milliseconds.
+ * @returns A new debounced function.
  */
 export declare function debounceLeading<T extends (...args: any[]) => void>(func: T, wait: number): T;
 /**
- * Creates a debounced version of a function that executes on the trailing edge.
- * @param {Function} func The function to debounce.
- * @param {number} wait The number of milliseconds to wait before invoking the function.
- * @returns {Function} The debounced function.
+ * Creates a debounced function that invokes `func` on the trailing edge of the `wait` timeout.
+ * The function is called only after `wait` milliseconds of inactivity.
+ *
+ * @template T - The type of the function.
+ * @param {T} func - The function to debounce.
+ * @param {number} wait - The debounce delay in milliseconds.
+ * @returns A new debounced function.
  */
 export declare function debounceTrailing<T extends (...args: any[]) => void>(func: T, wait: number): T;
 /**
- * Creates a debounced version of a function that executes on both leading and trailing edges.
- * @param {Function} func The function to debounce.
- * @param {number} wait The number of milliseconds to wait before invoking the function.
- * @returns {Function} The debounced function.
+ * Creates a debounced function that invokes `func` on both the leading and trailing edges of the `wait` timeout.
+ * This is useful for UIs where an action should happen immediately on the first event, but also after a pause in events.
+ *
+ * @template T - The type of the function.
+ * @param {T} func - The function to debounce.
+ * @param {number} wait - The debounce delay in milliseconds.
+ * @returns A new debounced function.
  */
 export declare function debounceLeadingTrailing<T extends (...args: any[]) => void>(func: T, wait: number): T;
 /**
- * Creates a debounced version of a function.
- * @param {Function} func The function to debounce.
- * @param {number} wait The number of milliseconds to wait before invoking the function.
- * @returns {Function} The debounced function.
+ * Creates a standard debounced function that delays invoking `func` until after `wait` milliseconds
+ * have elapsed since the last time the debounced function was invoked. (This is an alias for `debounceTrailing`).
+ *
+ * @template T - The type of the function.
+ * @param {T} func - The function to debounce.
+ * @param {number} wait - The debounce delay in milliseconds.
+ * @returns A new debounced function.
  */
 export declare function debounce<T extends (...args: any[]) => void>(func: T, wait: number): T;
 /**
- * Creates a throttled version of a function.
- * @param {Function} func The function to throttle.
- * @param {number} limit The number of milliseconds to wait between function calls.
- * @returns {Function} The throttled function.
+ * Creates a throttled function that only invokes `func` at most once per every `limit` milliseconds.
+ * This is useful for rate-limiting events that fire frequently, such as scrolling or resizing.
+ *
+ * @template T - The type of the function.
+ * @param {T} func - The function to throttle.
+ * @param {number} limit - The throttle duration in milliseconds.
+ * @returns A new throttled function.
  */
 export declare function throttle<T extends (...args: any[]) => void>(func: T, limit: number): T;

package/dist/utils/encryption.d.ts

@@ -1,40 +1,44 @@
 /**
- * Converts an ArrayBuffer or Uint8Array to a hexadecimal string.
- * @param buffer The ArrayBuffer or Uint8Array to convert.
- * @returns The hexadecimal string.
+ * Converts an `ArrayBuffer` or `Uint8Array` into a hexadecimal string representation.
+ *
+ * @param {ArrayBuffer | Uint8Array} buffer - The buffer to convert.
+ * @returns {string} The resulting hexadecimal string.
  */
 export declare function ab2hex(buffer: ArrayBuffer | Uint8Array): string;
 /**
- * Converts a hexadecimal string to a Uint8Array.
- * @param hex The hexadecimal string to convert.
- * @returns The Uint8Array.
+ * Converts a hexadecimal string into a `Uint8Array`.
+ *
+ * @param {string} hex - The hexadecimal string to convert.
+ * @returns {Uint8Array} The resulting `Uint8Array`.
  * @throws {TypeError} If the input is not a string.
- * @throws {Error} If the hexadecimal string format is invalid or has an odd length.
+ * @throws {Error} If the hexadecimal string has an invalid format or an odd length.
  */
 export declare function hex2ab(hex: string): Uint8Array;
 /**
- * Derives an encryption key from a secret key.
- * @param secretKey The secret key in plain text.
- * @returns A promise that resolves with the derived CryptoKey.
- * @throws {Error} If the secretKey is null or empty.
+ * Derives a `CryptoKey` for AES-CBC encryption from a plain-text secret key.
+ * It uses SHA-256 to hash the secret key, ensuring a fixed-length key suitable for the Web Crypto API.
+ *
+ * @param {string} secretKey - The plain-text secret key.
+ * @returns {Promise<CryptoKey>} A promise that resolves with the derived `CryptoKey`.
+ * @throws {Error} If the `secretKey` is null or empty.
  */
 export declare function importKey(secretKey: string): Promise<CryptoKey>;
 /**
- * Encrypts a value with the provided secret key.
- * @param value The value to encrypt.
- * @param secretKey The secret key for encryption.
- * @returns A promise that resolves with the IV (hex) + ciphertext (hex) string.
- * @throws {Error} If the secretKey is null or empty (via importKey).
+ * Encrypts a plain-text value using AES-CBC with a given secret key.
+ * A random 16-byte initialization vector (IV) is generated for each encryption.
+ *
+ * @param {string} value - The plain-text string to encrypt.
+ * @param {string} secretKey - The secret key to use for encryption.
+ * @returns {Promise<string>} A promise that resolves with a concatenated hexadecimal string of the IV and the ciphertext.
+ * @throws {Error} If the `secretKey` is null or empty.
  */
 export declare function encrypt(value: string, secretKey: string): Promise<string>;
 /**
- * Decrypts an encrypted value.
- * @param encryptedValue The encrypted string (IV_hex + ciphertext_hex).
- * @param secretKey The secret key for decryption.
- * @returns A promise that resolves with the decrypted value.
- * @throws {Error} If encryptedValue is null or empty, too short,
- * or if the IV/ciphertext have incorrect lengths after conversion.
- * @throws {Error} If the secretKey is null or empty (via importKey).
- * @throws {TypeError} If hex2ab receives an invalid input type.
+ * Decrypts a hexadecimal string (IV + ciphertext) using AES-CBC with a given secret key.
+ *
+ * @param {string} encryptedValue - The concatenated hexadecimal string of the IV and ciphertext.
+ * @param {string} secretKey - The secret key to use for decryption.
+ * @returns {Promise<string>} A promise that resolves with the decrypted plain-text string.
+ * @throws {Error} If the encrypted value is null, empty, or too short, or if the `secretKey` is invalid.
  */
 export declare function decrypt(encryptedValue: string, secretKey: string): Promise<string>;

package/dist/utils/errors.d.ts

@@ -1,10 +1,29 @@
-import { ErrorPassMethod } from '@/types';
+import { ErrorType } from '@/types';
+export interface ErrorInfo {
+    message: string;
+    type: ErrorType;
+    errorData?: Record<string, unknown>;
+}
 /**
- * Maneja y registra errores en la consola, además de permitir redirecciones configurables.
- * @param error - Error capturado (string o Error)
- * @param redirect - `true` si se quiere redirigir a una página de error
- * @param route - Ruta personalizada para la página de error (por defecto: `/error`)
- * @param passMethod - Método para pasar el error a la ruta (`query`, `localStorage`, `sessionStorage`)
- * @returns Mensaje user-friendly del error
+ * Handles and logs errors to the console. Supports both standard Error objects and custom error classes
+ * (BaseError, NetworkError, etc.). It infers the error type, logs a styled message with detailed information,
+ * and returns structured error information for further handling.
+ *
+ * @param {unknown} error - The captured error, which can be a string, Error object, or custom error class.
+ * @returns {ErrorInfo | undefined} An object containing the error message, type, and additional error data,
+ *   or `undefined` if the error is not an Error instance.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await someOperation();
+ * } catch (error) {
+ *   const errorInfo = handleError(error);
+ *   if (errorInfo) {
+ *     // Use errorInfo.message, errorInfo.type, errorInfo.errorData
+ *     // Handle redirect or other actions as needed
+ *   }
+ * }
+ * ```
  */
-export declare function handleError(error: unknown, redirect?: boolean, route?: string, passMethod?: ErrorPassMethod): string | undefined;
+export declare function handleError(error: unknown): ErrorInfo | undefined;

package/dist/utils/exports.d.ts

@@ -1,34 +1,39 @@
 /**
- * Exports data to a CSV file.
- * @param {string[]} headers The headers for the CSV.
- * @param {any[][]} data The data to export, as an array of arrays.
- * @param {string} fileName The name of the file to create.
+ * Converts an array of data into a CSV format and triggers a download.
+ *
+ * @param {string[]} headers - An array of strings to be used as the CSV header row.
+ * @param {any[][]} data - A 2D array representing the rows and cells of the data to be exported.
+ * @param {string} fileName - The desired name for the downloaded CSV file.
  */
 export declare function exportToCSV(headers: string[], data: any[][], fileName: string): void;
 /**
- * Exports data to an Excel file (.xls) using HTML table.
- * @param {string[]} headers The headers for the Excel file.
- * @param {any[][]} data The data to export, as an array of arrays.
- * @param {string} fileName The name of the file to create.
+ * Converts an array of data into an HTML table, then triggers a download as an Excel (.xls) file.
+ *
+ * @param {string[]} headers - An array of strings for the table headers.
+ * @param {any[][]} data - A 2D array of the data to be exported.
+ * @param {string} fileName - The desired name for the downloaded Excel file.
  */
 export declare function exportToExcel(headers: string[], data: any[][], fileName: string): void;
 /**
- * Exports data to a JSON file.
- * @param {any[]} data The data to export.
- * @param {string} fileName The name of the file to create.
+ * Converts an array of data into a pretty-printed JSON string and triggers a download.
+ *
+ * @param {any[]} data - The data to be serialized into JSON.
+ * @param {string} fileName - The desired name for the downloaded JSON file.
  */
 export declare function exportToJSON(data: any[], fileName: string): void;
 /**
- * Exports data to an XML file.
- * @param {string[]} headers The headers for the XML.
- * @param {any[][]} data The data to export, as an array of arrays.
- * @param {string} fileName The name of the file to create.
+ * Converts an array of data into a simple XML format and triggers a download.
+ *
+ * @param {string[]} headers - An array of strings to be used as column headers in the XML.
+ * @param {any[][]} data - A 2D array of the data to be exported.
+ * @param {string} fileName - The desired name for the downloaded XML file.
  */
 export declare function exportToXML(headers: string[], data: any[][], fileName: string): void;
 /**
- * Exports data to a plain text file.
- * @param {string[]} headers The headers for the text file.
- * @param {any[][]} data The data to export, as an array of arrays.
- * @param {string} fileName The name of the file to create.
+ * Converts an array of data into a tab-separated text format and triggers a download.
+ *
+ * @param {string[]} headers - An array of strings for the header row.
+ * @param {any[][]} data - A 2D array of the data to be exported.
+ * @param {string} fileName - The desired name for the downloaded text file.
  */
 export declare function exportToText(headers: string[], data: any[][], fileName: string): void;