@arex95/vue-core 1.1.43 → 3.0.1

package/dist/rest/RestStd.d.ts

@@ -1,111 +1,155 @@
+import { Fetcher } from "@/types/Fetcher";
+import { GetAllOptions, GetOneOptions, CreateOptions, UpdateOptions, PatchOptions, DeleteOptions, BulkCreateOptions, BulkUpdateOptions, BulkDeleteOptions, UpsertOptions, CustomRequestOptions } from "@/types/RestStdOptions";
+import { RetryConfig } from "@/utils/retry";
+/**
+ * A standardized RESTful class that provides a generic interface for performing
+ * CRUD (Create, Read, Update, Delete) operations on a specific API resource. It is designed
+ * to be extended directly from your models. It supports both JSON and FormData requests.
+ *
+ * @example
+ * ```typescript
+ * export class Role extends RestStd {
+ *     static override resource = 'roles';
+ *     static fetchFn = createAxiosFetcher(axiosInstance);
+ * }
+ *
+ * const roles = await Role.getAll();
+ * ```
+ */
 export declare class RestStd {
+    /**
+     * The resource endpoint. MUST be overridden in subclasses.
+     * @example static override resource = 'users';
+     */
     static resource: string;
+    /** A flag to determine if request data should be sent as FormData. Defaults to `false`. */
     static isFormData: boolean;
+    /** A record of global headers to be sent with every request. */
     static headers: Record<string, string>;
-    static fetchFn: Function;
+    /** The function used to make the actual HTTP requests. Optional, defaults to Axios fetcher. */
+    static fetchFn?: Fetcher;
+    /** Retry configuration for failed requests. Optional. */
+    static retryConfig?: RetryConfig;
     /**
-     * Set global headers for all requests.
-     * @param headers Object containing headers to be set globally.
+     * Validates that the resource property is defined.
+     * @throws {Error} If resource is not defined
+     */
+    protected static validateResource(): void;
+    /**
+     * Gets the fetcher function, using default if not provided.
+     * Creates a default Axios fetcher if not configured, allowing lazy initialization.
+     * @returns The fetcher function to use
+     */
+    private static getFetchFn;
+    /**
+     * Executes a fetch request with optional retry logic.
+     * @param config - The fetcher configuration
+     * @returns A promise that resolves with the response data
+     */
+    private static executeFetch;
+    /**
+     * Builds a URL by combining base URL and suffix.
+     * @param baseUrl - The base URL
+     * @param suffix - Optional suffix to append
+     * @returns The combined URL
+     */
+    private static buildUrl;
+    /**
+     * Sets global headers that will be included in all subsequent requests made by this class.
+     * @param headers - An object containing the headers to be set
      */
     static setHeaders(headers: Record<string, string>): void;
     /**
-     * Convert data to FormData if isFormData is true, otherwise return the data as is.
-     * @param data Data to be converted.
-     * @returns Data in FormData format or as is.
-     */
-    static transformData(data: any): any;
-    /**
-     * Fetch a list of items from the server.
-     *
-     * @param params Query parameters for filtering the results.
-     * @param options Additional options for the fetch function.
-     * @returns The result of the fetch function (typically a promise).
-     */
-    static getAll<T>(params?: Record<string, any>, options?: object): any;
-    /**
-     * Fetch a single item by ID from the server.
-     *
-     * @param id The ID of the item to fetch.
-     * @param params Additional query parameters for the request.
-     * @param options Additional options for the fetch function.
-     * @returns The result of the fetch function (typically a promise).
-     */
-    static getOne<T>(id: string | number, params?: Record<string, any>, options?: object): any;
-    /**
-     * Create a new item on the server.
-     *
-     * @param data The data for the new item to create.
-     * @param options Additional options for the fetch function.
-     * @returns The result of the fetch function (typically a promise).
-     */
-    static create<T>(data: any, options?: object): any;
-    /**
-     * Create multiple new items on the server.
-     *
-     * @param data An array of data for the items to create.
-     * @param options Additional options for the fetch function.
-     * @returns The result of the fetch function.
-     */
-    static bulkCreate<T>(data: any[], options?: object): any;
-    /**
-     * Update an existing item on the server.
-     *
-     * @param id The ID of the item to update.
-     * @param data The updated data for the item.
-     * @param options Additional options for the fetch function.
-     * @returns The result of the fetch function (typically a promise).
-     */
-    static update<T>(id: string | number, data: any, options?: object): any;
-    /**
-     * Update multiple existing items on the server.
-     *
-     * @param data An array of data for the items to update (each object should have an ID).
-     * @param options Additional options for the fetch function.
-     * @returns The result of the fetch function.
-     */
-    static bulkUpdate<T>(data: any[], options?: object): any;
-    /**
-     * Partially update an existing item on the server.
-     *
-     * @param id The ID of the item to update.
-     * @param data The updated data for the item.
-     * @param options Additional options for the fetch function.
-     * @returns The result of the fetch function (typically a promise).
-     */
-    static patch<T>(id: string | number, data: any, options?: object): any;
-    /**
-     * Delete an item from the server.
-     *
-     * @param id The ID of the item to delete.
-     * @param options Additional options for the fetch function.
-     * @returns The result of the fetch function (typically a promise).
-     */
-    static delete<T>(id: string | number, options?: object): any;
-    /**
-     * Delete multiple items from the server by their IDs.
-     *
-     * @param ids An array of IDs of the items to delete.
-     * @param options Additional options for the fetch function.
-     * @returns The result of the fetch function.
-     */
-    static bulkDelete<T>(ids: (string | number)[], options?: object): any;
-    /**
-     * Upsert method that decides whether to create or update based on the presence of 'id'.
-     *
-     * @param data The data for the item to create or update.
-     * @param options Additional options for the fetch function.
-     * @returns The result of the fetch function (typically a promise).
-     */
-    static upsert<T>(data: any, options?: object): any;
-    /**
-     * Custom request method for more flexibility.
-     *
-     * @param method HTTP method (GET, POST, etc.).
-     * @param url The custom URL for the request.
-     * @param params Query parameters.
-     * @param data Request body data.
-     * @param options Additional options for the fetch function.
-     * @returns The result of the fetch function (typically a promise).
-     */
-    static customRequest<T>(method: string, url: string, params?: Record<string, any>, data?: any, options?: object): any;
+     * Conditionally transforms the request data to FormData if `isFormData` is true.
+     * @param data - The data to be potentially transformed
+     * @returns The transformed data as FormData, or the original data
+     */
+    static transformData(data: unknown): FormData | unknown;
+    /**
+     * Fetches a list of items from the resource's endpoint.
+     * @template TResponse The expected response type
+     * @template TParams The type of query parameters
+     * @param options - Options including params, options, and optional url override
+     * @returns A promise that resolves with the response data
+     */
+    static getAll<TResponse = unknown, TParams extends Record<string, unknown> = Record<string, unknown>>(options?: GetAllOptions<TParams>): Promise<TResponse>;
+    /**
+     * Fetches a single item by its ID.
+     * @template TResponse The expected response type
+     * @template TParams The type of query parameters
+     * @param options - Options including id, params, options, and optional url override
+     * @returns A promise that resolves with the response data
+     */
+    static getOne<TResponse = unknown, TParams extends Record<string, unknown> = Record<string, unknown>>(options: GetOneOptions<TParams>): Promise<TResponse>;
+    /**
+     * Creates a new item.
+     * @template TResponse The expected response type
+     * @template TData The type of data to send
+     * @param options - Options including data, options, and optional url override
+     * @returns A promise that resolves with the response data
+     */
+    static create<TResponse = unknown, TData = unknown>(options: CreateOptions<TData>): Promise<TResponse>;
+    /**
+     * Creates multiple new items in a single request.
+     * @template TResponse The expected response type
+     * @template TData The type of data items to send
+     * @param options - Options including data array, options, and optional url override
+     * @returns A promise that resolves with the response data
+     */
+    static bulkCreate<TResponse = unknown, TData = unknown>(options: BulkCreateOptions<TData>): Promise<TResponse>;
+    /**
+     * Updates an existing item by its ID.
+     * @template TResponse The expected response type
+     * @template TData The type of data to send
+     * @param options - Options including id, data, options, and optional url override
+     * @returns A promise that resolves with the response data
+     */
+    static update<TResponse = unknown, TData = unknown>(options: UpdateOptions<TData>): Promise<TResponse>;
+    /**
+     * Updates multiple existing items in a single request.
+     * @template TResponse The expected response type
+     * @template TData The type of data items to send
+     * @param options - Options including data array, options, and optional url override
+     * @returns A promise that resolves with the response data
+     */
+    static bulkUpdate<TResponse = unknown, TData = unknown>(options: BulkUpdateOptions<TData>): Promise<TResponse>;
+    /**
+     * Partially updates an existing item by its ID.
+     * @template TResponse The expected response type
+     * @template TData The type of data to send (partial)
+     * @param options - Options including id, data, options, and optional url override
+     * @returns A promise that resolves with the response data
+     */
+    static patch<TResponse = unknown, TData = unknown>(options: PatchOptions<TData>): Promise<TResponse>;
+    /**
+     * Deletes an item by its ID.
+     * @template TResponse The expected response type
+     * @param options - Options including id, options, and optional url override
+     * @returns A promise that resolves with the response data
+     */
+    static delete<TResponse = unknown>(options: DeleteOptions): Promise<TResponse>;
+    /**
+     * Deletes multiple items by their IDs in a single request.
+     * @template TResponse The expected response type
+     * @param options - Options including ids array, options, and optional url override
+     * @returns A promise that resolves with the response data
+     */
+    static bulkDelete<TResponse = unknown>(options: BulkDeleteOptions): Promise<TResponse>;
+    /**
+     * Creates a new item or updates an existing one, based on the presence of an `id` property in the data.
+     * @template TResponse The expected response type
+     * @template TData The type of data to send (must have optional id)
+     * @param options - Options including data, options, and optional url override
+     * @returns A promise that resolves with the response data
+     */
+    static upsert<TResponse = unknown, TData = unknown>(options: UpsertOptions<TData>): Promise<TResponse>;
+    /**
+     * Makes a custom HTTP request, providing full flexibility over the method, URL, and data.
+     * @template TResponse The expected response type
+     * @template TParams The type of query parameters
+     * @template TData The type of request body data
+     * @param options - Options including method, url, params, data, and options
+     * @returns A promise that resolves with the response data
+     */
+    static customRequest<TResponse = unknown, TParams extends Record<string, unknown> = Record<string, unknown>, TData = unknown>(options: CustomRequestOptions<TParams, TData>): Promise<TResponse>;
 }

package/dist/services/credentials.d.ts

@@ -1,56 +1,51 @@
 import { LocationPreference } from "@/types/SessionConfig";
 /**
- * Clears all stored authentication data (access and refresh tokens)
- * from either sessionStorage, localStorage, or both based on the provided location preference.
+ * Removes all stored authentication credentials (access and refresh tokens) from the specified storage locations.
  *
- * @param {LocationPreference} location - The storage preference ('local' for localStorage, 'session' for sessionStorage, 'any' for both).
- * @returns {Promise<void>} A promise that resolves when all relevant storage items are removed.
+ * @param {LocationPreference} location - The storage location to clear. Can be 'local' for `localStorage`,
+ *   'session' for `sessionStorage`, 'cookie' for cookies, or 'any' to clear all.
+ * @returns {Promise<void>} A promise that resolves when the credentials have been cleared.
  */
 export declare const cleanCredentials: (location: LocationPreference) => Promise<void>;
 /**
- * Retrieves the authentication token (access token) from storage, decrypting it
- * using the provided secret key and based on the specified session preference.
+ * Retrieves and decrypts the access token from the specified storage location.
  *
- * @param {string} secretKey - The secret key used for decryption.
- * @param {SessionPreference} preference - The storage preference ('local' for localStorage, 'session' for sessionStorage).
- * @returns {Promise<string | null>} A promise that resolves with the decrypted access token, or null if not found.
+ * @param {string} secretKey - The secret key to use for decryption.
+ * @param {LocationPreference} location - The storage location to search ('local', 'session', 'cookie', or 'any').
+ * @returns {Promise<string | null>} A promise that resolves with the decrypted access token, or `null` if it's not found.
  */
 export declare const getAuthToken: (secretKey: string, location: LocationPreference) => Promise<string | null>;
 /**
- * Retrieves the authentication refresh token from storage, decrypting it
- * using the provided secret key and based on the specified session preference.
+ * Retrieves and decrypts the refresh token from the specified storage location.
  *
- * @param {string} secretKey - The secret key used for decryption.
- * @param {SessionPreference} preference - The storage preference ('local' for localStorage, 'session' for sessionStorage).
- * @returns {Promise<string | null>} A promise that resolves with the decrypted refresh token, or null if not found.
+ * @param {string} secretKey - The secret key to use for decryption.
+ * @param {LocationPreference} location - The storage location to search ('local', 'session', 'cookie', or 'any').
+ * @returns {Promise<string | null>} A promise that resolves with the decrypted refresh token, or `null` if it's not found.
  */
 export declare const getAuthRefreshToken: (secretKey: string, location: LocationPreference) => Promise<string | null>;
 /**
- * Stores the authentication token (access token) in storage after encrypting it,
- * based on the specified session preference.
+ * Encrypts and stores the access token in the specified storage location.
  *
  * @param {string} token - The access token to store.
- * @param {string} secretKey - The secret key used for encryption.
- * @param {SessionPreference} preference - The storage preference ('local' for localStorage, 'session' for sessionStorage).
- * @returns {Promise<void>} A promise that resolves when the token is successfully stored.
+ * @param {string} secretKey - The secret key to use for encryption.
+ * @param {LocationPreference} location - The storage location ('local', 'session', or 'cookie').
+ * @returns {Promise<void>} A promise that resolves when the token has been stored.
  */
 export declare const storeAuthToken: (token: string, secretKey: string, location: LocationPreference) => Promise<void>;
 /**
- * Stores the authentication refresh token in storage after encrypting it,
- * based on the specified session preference.
+ * Encrypts and stores the refresh token in the specified storage location.
  *
  * @param {string} token - The refresh token to store.
- * @param {string} secretKey - The secret key used for encryption.
- * @param {SessionPreference} preference - The storage preference ('local' for localStorage, 'session' for sessionStorage).
- * @returns {Promise<void>} A promise that resolves when the token is successfully stored.
+ * @param {string} secretKey - The secret key to use for encryption.
+ * @param {LocationPreference} location - The storage location ('local', 'session', or 'cookie').
+ * @returns {Promise<void>} A promise that resolves when the token has been stored.
  */
 export declare const storeAuthRefreshToken: (token: string, secretKey: string, location: LocationPreference) => Promise<void>;
 /**
- * Verifies the validity and expiration of the current authentication token.
- * If the token is missing, invalid, or expired, appropriate errors are thrown and credentials are cleaned.
+ * Verifies the current user's authentication status by checking for a valid, unexpired access token.
+ * It searches for the token in all storage locations (sessionStorage, localStorage, cookies).
+ * If the token is missing, malformed, or expired, it logs the issue, clears credentials, and returns `false`.
  *
- * @returns {Promise<boolean>} True if the token is valid and unexpired.
- * @throws {Error} "TOKEN_MISSING" if no token is found, "TOKEN_EXPIRED" if the token has expired,
- * "TOKEN_INVALID" if the token format is invalid.
+ * @returns {Promise<boolean>} A promise that resolves to `true` if the user is authenticated, and `false` otherwise.
  */
 export declare const verifyAuth: () => Promise<boolean>;

package/dist/services/extractTokens.d.ts

@@ -1,12 +1,13 @@
 import { AuthTokenPaths } from "@/types";
 import { TokenValidationResult } from '@/types';
 /**
- * Extracts and validates the access and refresh tokens from a response object.
- * Throws an error if the tokens are not found or are invalid.
+ * Extracts access and refresh tokens from a response object using specified dot-notation paths
+ * and validates their existence and type.
  *
- * @param {any} data - The API response object.
- * @param {AuthTokenPaths} tokenPaths - The paths for the tokens.
- * @param {string} errorSource - A prefix for the error message ("LOGIN" or "REFRESH").
- * @returns {TokenValidationResult} An object with the validated tokens.
+ * @param {any} data - The response object from which to extract the tokens.
+ * @param {AuthTokenPaths} tokenPaths - An object containing the dot-notation paths for the access and refresh tokens.
+ * @param {string} errorSource - A string to identify the source of the operation (e.g., "LOGIN", "REFRESH") for error messages.
+ * @returns {TokenValidationResult} An object containing the extracted `accessToken` and `refreshToken`.
+ * @throws {Error} If the data object is missing, or if the access or refresh tokens cannot be found at the specified paths or are not strings.
  */
 export declare const extractAndValidateTokens: (data: any, tokenPaths: AuthTokenPaths, errorSource: string) => TokenValidationResult;

package/dist/services/refreshTokens.d.ts

@@ -1,13 +1,12 @@
-import { AuthResponse } from "@/types";
-import { AxiosInstance } from 'axios';
+import { AuthResponse, Fetcher } from "@/types";
 /**
-   * Refreshes the authentication tokens using the stored refresh token.
-   * This function can also accept optional token paths if the refresh endpoint
-   * returns tokens with a different structure than the default login.
-   * If no refresh token is found, it throws an error and initiates a logout.
-   *
-   * @param {AuthTokenPaths} [tokenPaths] - Optional configuration for the paths (in dot notation) of the access and refresh tokens in the refresh endpoint response.
-   * @returns {Promise<AuthResponse>} The new authentication response with refreshed tokens.
-   * @throws {Error} If the refresh token is missing or the refresh request fails.
-   */
-export declare const refreshTokens: (axiosInstance: AxiosInstance) => Promise<AuthResponse>;
+ * Refreshes the access and refresh tokens by making a POST request to the refresh endpoint.
+ * It retrieves the current refresh token from storage, sends it to the refresh endpoint,
+ * and then stores the new tokens upon a successful response. If the refresh process fails
+ * or no refresh token is found, it clears all credentials and reloads the page.
+ *
+ * @param {Fetcher} [fetcher] - Optional fetcher function to use for the refresh request. If not provided, uses the default configured fetcher.
+ * @returns {Promise<AuthResponse>} A promise that resolves with the new authentication response containing the refreshed tokens.
+ * @throws {Error} Throws an error if the refresh token is missing or if the refresh request fails, which is then caught to trigger a logout.
+ */
+export declare const refreshTokens: (fetcher?: Fetcher) => Promise<AuthResponse>;

package/dist/services/storeTokens.d.ts

@@ -1,9 +1,11 @@
 import { LocationPreference } from "@/types";
 /**
-* Stores the access and refresh tokens in the appropriate storage based on the user's preference.
-*
-* @param {string} accessToken - El token de acceso.
-* @param {string} refreshToken - El token de refresco.
-* @param {LocationPreference} persistence - La preferencia de almacenamiento.
-*/
+ * Encrypts and stores both the access and refresh tokens in the specified storage location.
+ * Supports localStorage, sessionStorage, and cookies (with encryption and security options).
+ *
+ * @param {string} accessToken - The access token to be stored.
+ * @param {string} refreshToken - The refresh token to be stored.
+ * @param {LocationPreference} persistence - The desired storage location: 'local' for `localStorage`, 'session' for `sessionStorage`, or 'cookie' for cookies.
+ * @returns {Promise<void>} A promise that resolves when both tokens have been successfully stored.
+ */
 export declare const storeTokens: (accessToken: string, refreshToken: string, persistence: LocationPreference) => Promise<void>;

package/dist/types/AppKeyConfig.d.ts

@@ -1,3 +1,10 @@
+/**
+ * Defines the structure for the application key configuration object.
+ * This interface is used to ensure that the application key is provided in the correct format.
+ */
 export interface AppKeyConfig {
+    /**
+     * The application key, used for encryption and other security-related operations.
+     */
     appKey: string;
 }

package/dist/types/ArexVueCoreOptions.d.ts

@@ -1,22 +1,42 @@
 import { AxiosServiceOptions } from "./AxiosServiceOptions";
+/**
+ * Defines the comprehensive configuration object for initializing the Arex-Vue-Core library.
+ * This interface gathers all the necessary settings, from API endpoints and token configurations
+ * to the application key and Axios-specific options, providing a single point of configuration.
+ */
 export interface ArexVueCoreOptions {
+    /** The secret key for encryption and decryption operations. */
     appKey: string;
+    /** An object containing the authentication-related API endpoints. */
     endpoints: {
+        /** The endpoint for user login. */
         login: string;
+        /** The endpoint for refreshing authentication tokens. */
         refresh: string;
+        /** The endpoint for user logout. */
         logout: string;
     };
+    /** An object defining the keys for storing tokens in local/session storage. */
     tokenKeys: {
+        /** The storage key for the access token. */
         accessToken: string;
+        /** The storage key for the refresh token. */
         refreshToken: string;
     };
+    /** An object specifying the dot-notation paths to find tokens in the login response. */
     tokenPaths: {
+        /** The path to the access token in the login response data. */
         accessToken: string;
+        /** The path to the refresh token in the login response data. */
         refreshToken: string;
     };
+    /** An object specifying the dot-notation paths to find tokens in the refresh token response. */
     refreshTokenPaths: {
+        /** The path to the access token in the refresh response data. */
         accessToken: string;
+        /** The path to the refresh token in the refresh response data. */
         refreshToken: string;
     };
+    /** The configuration options for the underlying Axios instance. */
     axios: AxiosServiceOptions;
 }

package/dist/types/Auth.d.ts

@@ -1,12 +1,27 @@
 import { TokensConfig, EndpointsConfig } from "@/types";
+/**
+ * Defines the configuration for authentication-related settings, including API endpoints and storage keys.
+ */
 export type AuthConfig = {
+    /** The API endpoints for login, refresh, and logout operations. */
     endpoints: EndpointsConfig;
+    /** The keys used to store authentication tokens in local or session storage. */
     storageKeys: TokensConfig;
 };
+/**
+ * Defines the structure for specifying the dot-notation paths to the access and refresh tokens
+ * within an API response. This allows for flexibility in handling different response structures.
+ */
 export interface AuthTokenPaths {
+    /** The path to the access token in the response data (e.g., 'data.accessToken'). */
     accessTokenPath?: string;
+    /** The path to the refresh token in the response data (e.g., 'data.refreshToken'). */
     refreshTokenPath?: string;
 }
+/**
+ * Represents a generic authentication response from the API.
+ * Since the structure of the response can vary, it allows for any number of properties of any type.
+ */
 export interface AuthResponse {
     [key: string]: any;
 }

package/dist/types/AxiosOptionsParameter.d.ts

@@ -1,31 +1,38 @@
 import { MaybeRef } from 'vue';
 import { AxiosRequestConfig } from 'axios';
 /**
- * Type for options passed to an Axios fetch request.
+ * Defines a set of advanced options for controlling the behavior of an Axios-based fetch request.
+ * This includes features like immediate execution, default values, debouncing, and retry logic.
+ *
+ * @template T The expected type of the `defaultValue`.
  */
 export type AxiosOptionsParameter<T = any> = {
     /**
-     * A boolean or a reactive reference to a boolean indicating if the request is enabled by default.
+     * If `true`, the request is executed immediately upon creation. Can be a reactive `Ref`.
+     * @default false
      */
     immediate?: MaybeRef<boolean>;
     /**
-     * A default value to be used if the request does not return data.
+     * A default value to be used for the response data before the request completes or if it fails.
      */
     defaultValue?: T;
     /**
-     * Axios configuration options for the request.
+     * Additional Axios-specific configuration for the request, such as headers, params, etc.
      */
     axiosOptionFetch?: AxiosRequestConfig;
     /**
-     * Delay in milliseconds to debounce the request.
+     * The debounce interval in milliseconds. If provided, the request will be delayed until
+     * this amount of time has passed without any new calls.
      */
     debounce?: number;
     /**
-     * Maximum number of retries for the request on failure.
+     * The maximum number of times to retry the request if it fails.
+     * @default 0
      */
     maxRetries?: number;
     /**
-     * Delay in milliseconds between retry attempts.
+     * The delay in milliseconds between retry attempts.
+     * @default 1000
      */
     retryDelay?: number;
 };

package/dist/types/AxiosServiceOptions.d.ts

@@ -1,6 +1,15 @@
+/**
+ * Defines the configuration options for creating a new `AxiosService` instance.
+ * This interface allows for setting the base URL, default headers, request timeout,
+ * and credential handling for all requests made by the instance.
+ */
 export interface AxiosServiceOptions {
+    /** The base URL that will be prepended to all request URLs. */
     baseURL: string;
+    /** A record of default headers to be sent with every request. */
     headers?: Record<string, string>;
+    /** The request timeout in milliseconds. */
     timeout?: number;
+    /** A boolean indicating whether cross-site Access-Control requests should be made using credentials. */
     withCredentials?: boolean;
 }

package/dist/types/DecodedJwtPayload.d.ts

@@ -1,9 +1,21 @@
+/**
+ * Represents the payload of a decoded JSON Web Token (JWT).
+ * This interface includes the standard registered claims (`exp`, `iat`, etc.)
+ * as well as an index signature to allow for any custom claims.
+ */
 export interface DecodedJwtPayload {
+    /** The expiration time of the token, as a Unix timestamp. */
     exp?: number;
+    /** The time the token was issued, as a Unix timestamp. */
     iat?: number;
+    /** The time before which the token must not be accepted for processing, as a Unix timestamp. */
     nbf?: number;
+    /** The issuer of the token. */
     iss?: string;
+    /** The subject of the token. */
     sub?: string;
+    /** The audience of the token. */
     aud?: string | string[];
+    /** Allows for any other custom claims to be present in the payload. */
     [key: string]: unknown;
 }

package/dist/types/EndpointsConfig.d.ts

@@ -1,5 +1,12 @@
+/**
+ * Defines the structure for the authentication endpoints configuration object.
+ * This type ensures that the necessary endpoints for login, token refresh, and logout are defined.
+ */
 export type EndpointsConfig = {
+    /** The URL for the login endpoint. */
     LOGIN: string;
+    /** The URL for the token refresh endpoint. */
     REFRESH: string;
+    /** The URL for the logout endpoint. */
     LOGOUT: string;
 };

package/dist/types/ErrorType.d.ts

@@ -1,8 +1,10 @@
 /**
- * Tipos de errores permitidos
+ * Defines a union type of allowed error categories. This provides a standardized set of
+ * error types that can be used throughout the application for consistent error handling and logging.
  */
 export type ErrorType = 'warning' | 'error' | 'critical' | 'validation' | 'component' | 'network' | 'authentication' | 'runtime' | 'type' | 'reference' | 'syntax' | 'range' | 'eval' | 'uri';
 /**
- * Métodos disponibles para pasar errores a la ruta
+ * Defines the available methods for passing error information between routes or components.
+ * This can be done via URL query parameters, or by using `localStorage` or `sessionStorage`.
  */
 export type ErrorPassMethod = 'query' | 'localStorage' | 'sessionStorage';