fiscalapi 1.0.0

package/dist/types/abstractions/catalog-service.interface.d.ts

@@ -0,0 +1,27 @@
+import { IFiscalapiService } from './fiscalapi-service.interface';
+import { CatalogDto } from '../common/catalog-dto';
+import { ApiResponse } from '../common/api-response';
+import { PagedList } from '../common/paged-list';
+/**
+ * Interfaz del servicio de catálogos
+ */
+export interface ICatalogService extends IFiscalapiService<CatalogDto> {
+    /**
+     * /api/v4/catalogs/<catalogName>/key/<id>
+     * Recupera un registro específico por catalogName e id
+     *
+     * @param catalogName - Nombre del catálogo
+     * @param id - Identificador del registro
+     */
+    getRecordById(catalogName: string, id: string): Promise<ApiResponse<CatalogDto>>;
+    /**
+     * GET /api/v4/catalogs/{catalogName}/{searchText}
+     * Busca registros en un catálogo específico
+     *
+     * @param catalogName - Nombre del catálogo
+     * @param searchText - Texto de búsqueda
+     * @param pageNumber - Número de página (opcional, default: 1)
+     * @param pageSize - Tamaño de página (opcional, default: 50)
+     */
+    searchCatalog(catalogName: string, searchText: string, pageNumber?: number, pageSize?: number): Promise<ApiResponse<PagedList<CatalogDto>>>;
+}

package/dist/types/abstractions/fiscalapi-client.interface.d.ts

@@ -0,0 +1,35 @@
+import { IApiKeyService } from './api-key-service.interface';
+import { ICatalogService } from './catalog-service.interface';
+import { IInvoiceService } from './invoice-service.interface';
+import { IPersonService } from './person-service.interface';
+import { IProductService } from './product-service.interface';
+import { ITaxFileService } from './tax-file-service.interface';
+/**
+ * Interfaz principal del cliente para FiscalAPI
+ */
+export interface IFiscalapiClient {
+    /**
+     * Servicio de facturas
+     */
+    invoices: IInvoiceService;
+    /**
+     * Servicio de productos
+     */
+    products: IProductService;
+    /**
+     * Servicio de personas
+     */
+    persons: IPersonService;
+    /**
+     * Servicio de claves de API
+     */
+    apiKeys: IApiKeyService;
+    /**
+     * Servicio de catálogos
+     */
+    catalogs: ICatalogService;
+    /**
+     * Servicio de archivos fiscales
+     */
+    taxFiles: ITaxFileService;
+}

package/dist/types/abstractions/fiscalapi-service.interface.d.ts

@@ -0,0 +1,94 @@
+import { AxiosRequestConfig } from 'axios';
+import { ApiResponse } from '../common/api-response';
+import { BaseDto } from '../common/base-dto';
+import { PagedList } from '../common/paged-list';
+import { HttpMethod } from '../http/fiscalapi-http-client.interface';
+/**
+ * Opciones para ejecutar una operación
+ * @template TData - Tipo de datos de entrada
+ */
+export type OperationOptions<TData = any> = {
+    /** Ruta o nombre de la operación */
+    path: string;
+    /** Datos para la operación (opcional) */
+    data?: TData;
+    /** Parámetros de consulta (opcional) */
+    queryParams?: Record<string, string>;
+    /** Método HTTP a utilizar */
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    /** Configuración adicional para Axios (opcional) */
+    config?: AxiosRequestConfig;
+};
+/**
+ * Opciones para ejecutar una petición personalizada
+ * @template TData - Tipo de datos de entrada
+ */
+export type RequestOptions<TData = any> = {
+    /** Método HTTP a utilizar */
+    method: HttpMethod;
+    /** Ruta adicional (opcional) */
+    path?: string;
+    /** ID del recurso (opcional) */
+    id?: string;
+    /** Datos para la petición (opcional) */
+    data?: TData;
+    /** Parámetros de consulta (opcional) */
+    queryParams?: Record<string, string>;
+    /** Configuración adicional para Axios (opcional) */
+    config?: AxiosRequestConfig;
+    /** Transformador personalizado para la respuesta (opcional) */
+    responseTransformer?: <T>(response: any) => T;
+};
+/**
+ * Interfaz base para todos los servicios de FiscalAPI
+ * @template T - Tipo de DTO que maneja el servicio
+ */
+export interface IFiscalapiService<T extends BaseDto> {
+    /**
+     * Recupera una lista paginada de recursos
+     * @param {number} pageNumber - Número de página (base 1)
+     * @param {number} pageSize - Número de elementos por página
+     * @returns {Promise<ApiResponse<PagedList<T>>>} Lista paginada de recursos
+     */
+    getList(pageNumber: number, pageSize: number): Promise<ApiResponse<PagedList<T>>>;
+    /**
+     * Recupera un recurso específico por ID
+     * @param {string} id - ID del recurso
+     * @param {boolean} [details=false] - Si es verdadero, incluye objetos relacionados
+     * @returns {Promise<ApiResponse<T>>} Recurso solicitado
+     */
+    getById(id: string, details?: boolean): Promise<ApiResponse<T>>;
+    /**
+     * Crea un nuevo recurso
+     * @param {T} model - Datos del recurso
+     * @returns {Promise<ApiResponse<T>>} Recurso creado
+     */
+    create(model: T): Promise<ApiResponse<T>>;
+    /**
+     * Actualiza un recurso existente
+     * @param {string} id - ID del recurso
+     * @param {T} model - Datos actualizados del recurso
+     * @returns {Promise<ApiResponse<T>>} Recurso actualizado
+     */
+    update(model: T): Promise<ApiResponse<T>>;
+    /**
+     * Elimina un recurso
+     * @param {string} id - ID del recurso
+     * @returns {Promise<ApiResponse<boolean>>} Resultado de la operación
+     */
+    delete(id: string): Promise<ApiResponse<boolean>>;
+    /**
+     * Realiza una búsqueda en el recurso
+     * @param {Record<string, string>} searchParams - Parámetros de búsqueda
+     * @returns {Promise<ApiResponse<PagedList<T>>>} Resultados de la búsqueda
+     */
+    search(searchParams: Record<string, string>): Promise<ApiResponse<PagedList<T>>>;
+    /**
+     * Ejecuta una petición HTTP personalizada con máxima flexibilidad
+     * @param {RequestOptions<TData>} options - Opciones para la petición
+     * @returns {Promise<ApiResponse<TResult>>} Resultado de la petición
+     * @template TResult - Tipo de resultado esperado
+     * @template TData - Tipo de datos de entrada
+     */
+    executeRequest<TResult, TData = any>(options: RequestOptions<TData>): Promise<ApiResponse<TResult>>;
+}

package/dist/types/abstractions/invoice-service.interface.d.ts

@@ -0,0 +1,39 @@
+import { ApiResponse } from '../common/api-response';
+import { FileResponse } from '../common/file-response';
+import { Invoice, CancelInvoiceRequest, CancelInvoiceResponse, CreatePdfRequest, SendInvoiceRequest, InvoiceStatusRequest, InvoiceStatusResponse } from '../models/invoice';
+import { IFiscalapiService } from './fiscalapi-service.interface';
+/**
+ * Interfaz para el servicio de facturas
+ */
+export interface IInvoiceService extends IFiscalapiService<Invoice> {
+    /**
+     * Cancela una factura
+     * @param {CancelInvoiceRequest} request - Solicitud para cancelar factura
+     * @returns {Promise<ApiResponse<CancelInvoiceResponse>>} Respuesta de la cancelación
+     */
+    cancel(request: CancelInvoiceRequest): Promise<ApiResponse<CancelInvoiceResponse>>;
+    /**
+     * Obtiene el PDF de una factura
+     * @param {CreatePdfRequest} request - Solicitud para crear PDF
+     * @returns {Promise<ApiResponse<FileResponse>>} Respuesta con el archivo PDF
+     */
+    getPdf(request: CreatePdfRequest): Promise<ApiResponse<FileResponse>>;
+    /**
+     * Obtiene el XML de una factura
+     * @param {string} id - ID de la factura
+     * @returns {Promise<ApiResponse<FileResponse>>} Respuesta con el archivo XML
+     */
+    getXml(id: string): Promise<ApiResponse<FileResponse>>;
+    /**
+     * Envía una factura por correo electrónico
+     * @param {SendInvoiceRequest} request - Solicitud para enviar factura
+     * @returns {Promise<ApiResponse<boolean>>} Resultado de la operación
+     */
+    send(request: SendInvoiceRequest): Promise<ApiResponse<boolean>>;
+    /**
+     * Obtiene el estado de una factura
+     * @param {InvoiceStatusRequest} request - Solicitud para consultar estado
+     * @returns {Promise<ApiResponse<InvoiceStatusResponse>>} Respuesta con el estado de la factura
+     */
+    getStatus(request: InvoiceStatusRequest): Promise<ApiResponse<InvoiceStatusResponse>>;
+}

package/dist/types/abstractions/person-service.interface.d.ts

@@ -0,0 +1,7 @@
+import { IFiscalapiService } from './fiscalapi-service.interface';
+import { Person } from '../models/person';
+/**
+ * Interfaz del servicio de personas
+ */
+export interface IPersonService extends IFiscalapiService<Person> {
+}

package/dist/types/abstractions/product-service.interface.d.ts

@@ -0,0 +1,7 @@
+import { IFiscalapiService } from './fiscalapi-service.interface';
+import { Product } from '../models/product';
+/**
+ * Interfaz del servicio de productos
+ */
+export interface IProductService extends IFiscalapiService<Product> {
+}

package/dist/types/abstractions/tax-file-service.interface.d.ts

@@ -0,0 +1,22 @@
+import { IFiscalapiService } from './fiscalapi-service.interface';
+import { TaxFile } from '../models/tax-file';
+import { ApiResponse } from '../common/api-response';
+/**
+ * Interfaz del servicio de archivos fiscales
+ */
+export interface ITaxFileService extends IFiscalapiService<TaxFile> {
+    /**
+       * Obtiene el último par de ids de certificados válidos y vigente de una persona. Es decir sus certificados por defecto (ids)
+       *
+       * @param personId - Id de la persona propietaria de los certificados
+       * @returns Promise que resuelve en una respuesta API con una lista de un par de certificados, pero sin contenido, solo sus Ids
+       */
+    getDefaultReferences(personId: string): Promise<ApiResponse<TaxFile[]>>;
+    /**
+      * Obtiene el último par de certificados válidos y vigente de una persona. Es decir sus certificados por defecto
+      *
+      * @param personId - Id de la persona dueña de los certificados
+      * @returns Promise que resuelve en una respuesta API con una lista de un par de certificados
+      */
+    getDefaultValues(personId: string): Promise<ApiResponse<TaxFile[]>>;
+}

package/dist/types/common/api-response.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Encapsulador genérico para respuestas de la API
+ * @template T
+ */
+export interface ApiResponse<T> {
+    /**
+     * Datos de la respuesta
+     */
+    data: T;
+    /**
+     * Indica si la petición fue exitosa
+     */
+    succeeded: boolean;
+    /**
+     * Mensaje de error o de éxito
+     */
+    message: string;
+    /**
+     * Detalles adicionales del error
+     */
+    details: string;
+    /**
+     * Código de estado HTTP
+     */
+    httpStatusCode: number;
+}
+/**
+* Detalles de errores de validación
+*/
+export interface ValidationFailure {
+    /**
+     * Nombre de la propiedad que falló en la validación
+     */
+    propertyName: string;
+    /**
+     * Mensaje de error
+     */
+    errorMessage: string;
+}
+/**
+ * Interfaz para los detalles de problemas según RFC 9457
+ */
+export interface ProblemDetails {
+    /** URI de referencia que identifica el tipo de problema */
+    type: string;
+    /** Resumen breve y legible del tipo de problema */
+    title: string;
+    /** Código de estado HTTP */
+    status: number;
+    /** Explicación específica y legible de esta ocurrencia del problema */
+    detail: string;
+    /** URI de referencia que identifica la ocurrencia específica del problema */
+    instance?: string;
+    /** Propiedades adicionales extendidas */
+    [key: string]: unknown;
+}

package/dist/types/common/auditable-dto.d.ts

@@ -0,0 +1,9 @@
+import { DateTime } from 'luxon';
+import { SerializableDto } from './serializable-dto';
+/**
+ * Clase que extiende SerializableDto agregando propiedades de auditoría
+ */
+export declare class AuditableDto extends SerializableDto {
+    createdAt?: DateTime;
+    updatedAt?: DateTime;
+}

package/dist/types/common/base-dto.d.ts

@@ -0,0 +1,7 @@
+import { AuditableDto } from "./auditable-dto";
+/**
+ * Clase base para todos los DTOs de la API
+ */
+export declare class BaseDto extends AuditableDto {
+    id?: string;
+}

package/dist/types/common/catalog-dto.d.ts

@@ -0,0 +1,8 @@
+import { BaseDto } from "./base-dto";
+export declare class CatalogDto extends BaseDto {
+    /**
+     * Catalog description
+     * @example "Catalogo de formas de pago"
+     */
+    description?: string;
+}

package/dist/types/common/file-response.d.ts

@@ -0,0 +1,18 @@
+/**
+ * File response from the API.
+ *Por ejemplo: Modelo de respuesta de generación de PDF o recuperación de XML
+ */
+export interface FileResponse {
+    /**
+     * File content as a base64 string
+     */
+    base64Content: string;
+    /**
+     * File name
+     */
+    fileName: string;
+    /**
+     * Content type
+     */
+    contentType: string;
+}

package/dist/types/common/fiscalapi-settings.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Configuración para el cliente de FiscalAPI
+ */
+export interface FiscalapiSettings {
+    /**
+   * URL base de la API de FiscalAPI
+   */
+    apiUrl: string;
+    /**
+     * Clave de API para autenticación
+     */
+    apiKey: string;
+    /**
+     * Versión de la API (predeterminado: 'v4')
+     */
+    apiVersion?: string;
+    /**
+     * Identificador del inquilino
+     */
+    tenant: string;
+    /**
+     * Zona horaria para la API (predeterminado: 'America/Mexico_City')
+     */
+    timeZone?: string;
+    /**
+     * Indica si de debe ejecutar en modo depuración, esto es, si se deben mostrar los logs de la API y deshabilitar la validación del certificado SSL
+     * @default false
+     */
+    debug?: boolean;
+}

package/dist/types/common/paged-list.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Lista paginada genérica para respuestas de la API
+ * @template T
+ */
+export declare class PagedList<T> {
+    /**
+     * Número de página actual
+     */
+    pageNumber: number;
+    /**
+     * Tamaño de página
+     */
+    pageSize: number;
+    /**
+     * Número total de elementos en todas las páginas
+     */
+    totalItems: number;
+    /**
+     * Número total de páginas
+     */
+    totalPages: number;
+    /**
+     * Indica si hay una página anterior
+     */
+    hasPreviousPage: boolean;
+    /**
+     * Indica si hay una página siguiente
+     */
+    hasNextPage: boolean;
+    /**
+     * Elementos en la página actual
+     */
+    items: T[];
+    /**
+     * Comprueba si la colección está vacía
+     * @returns {boolean} Verdadero si la colección está vacía
+     */
+    isEmpty(): boolean;
+}

package/dist/types/common/serializable-dto.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Clase base que proporciona funcionalidad de serialización para modelos de datos
+ */
+export declare class SerializableDto {
+    /**
+     * Convierte la instancia a una representación JSON en forma de string
+     * @returns {string} Representación JSON del objeto
+     */
+    toString(): string;
+}

package/dist/types/http/fiscalapi-http-client-factory.d.ts

@@ -0,0 +1,22 @@
+import { FiscalapiSettings } from '../common/fiscalapi-settings';
+import { IFiscalapiHttpClient } from './fiscalapi-http-client.interface';
+/**
+ * Fábrica para crear clientes HTTP para FiscalAPI
+ */
+export declare class FiscalapiHttpClientFactory {
+    private static clients;
+    /**
+     * Crea un nuevo cliente HTTP para FiscalAPI
+     * @param {FiscalapiSettings} settings - Configuración de FiscalAPI
+     * @returns {IFiscalapiHttpClient} Instancia del cliente HTTP
+     * @throws {Error} Si la configuración es nula o indefinida
+     */
+    static create(settings: FiscalapiSettings): IFiscalapiHttpClient;
+    /**
+     * Crea una instancia de Axios configurada según los ajustes de FiscalAPI
+     * @param {FiscalapiSettings} settings - Configuración de FiscalAPI
+     * @returns {AxiosInstance} Instancia de Axios configurada
+     * @private
+     */
+    private static createAxiosInstance;
+}

package/dist/types/http/fiscalapi-http-client.d.ts

@@ -0,0 +1,113 @@
+import { AxiosInstance, AxiosRequestConfig } from 'axios';
+import { FiscalapiSettings } from './../common/fiscalapi-settings';
+import { IFiscalapiHttpClient, HttpMethod, RequestOptions } from './fiscalapi-http-client.interface';
+import { ApiResponse } from '../common/api-response';
+/**
+ * Cliente HTTP para FiscalAPI
+ */
+export declare class FiscalapiHttpClient implements IFiscalapiHttpClient {
+    private readonly httpClient;
+    private readonly settings;
+    /**
+     * Crea una nueva instancia del cliente HTTP para FiscalAPI
+     * @param {AxiosInstance} httpClient - Instancia de Axios configurada
+     * @param {FiscalapiSettings} settings - Configuración para el cliente FiscalAPI
+     */
+    constructor(httpClient: AxiosInstance, settings: FiscalapiSettings);
+    /**
+     * Configura los interceptores para logear las peticiones y respuestas en modo debug
+     * @private
+     */
+    private setupDebugInterceptors;
+    /**
+     * Logea los detalles de una petición HTTP cuando el modo debug está activado
+     * @param {InternalAxiosRequestConfig} config - Configuración de la petición
+     * @private
+     */
+    private logRequest;
+    /**
+     * Logea los detalles de una respuesta HTTP cuando el modo debug está activado
+     * @param {AxiosResponse} response - Respuesta de la petición
+     * @private
+     */
+    private logResponse;
+    /**
+     * Ejecuta una petición HTTP genérica con control completo sobre los parámetros
+     * @param {HttpMethod} method - Método HTTP a utilizar
+     * @param {string} endpoint - Punto final de la API
+     * @param {RequestOptions<TData>} options - Opciones de la petición
+     * @returns {Promise<ApiResponse<TResult>>} Respuesta de la API
+     * @template TResult - Tipo de datos esperado en la respuesta
+     * @template TData - Tipo de datos a enviar en la petición (opcional)
+     */
+    executeRequest<TResult, TData = any>(method: HttpMethod, endpoint: string, options?: RequestOptions<TData>): Promise<ApiResponse<TResult>>;
+    /**
+     * Procesa la respuesta HTTP y la convierte en ApiResponse
+     * @param {AxiosResponse} response - Respuesta HTTP original
+     * @returns {ApiResponse<T>} Respuesta procesada
+     * @template T - Tipo de datos esperado
+     * @private
+     */
+    private processResponse;
+    /**
+     * Maneja los errores de las peticiones HTTP
+     * @param {unknown} error - Error capturado
+     * @returns {ApiResponse<T>} Respuesta de error estandarizada
+     * @template T - Tipo de datos esperado
+     * @private
+     */
+    private handleRequestError;
+    /**
+     * Realiza una petición GET a la API
+     * @param {string} endpoint - Punto final de la API
+     * @param {AxiosRequestConfig} [config] - Configuración adicional para la petición
+     * @returns {Promise<ApiResponse<T>>} Respuesta de la API
+     * @template T - Tipo de datos esperado en la respuesta
+     */
+    getAsync<T>(endpoint: string, config?: AxiosRequestConfig): Promise<ApiResponse<T>>;
+    /**
+     * Realiza una petición GET por ID a la API
+     * @param {string} endpoint - Punto final de la API con ID
+     * @param {AxiosRequestConfig} [config] - Configuración adicional para la petición
+     * @returns {Promise<ApiResponse<T>>} Respuesta de la API
+     * @template T - Tipo de datos esperado en la respuesta
+     */
+    getByIdAsync<T>(endpoint: string, config?: AxiosRequestConfig): Promise<ApiResponse<T>>;
+    /**
+     * Realiza una petición POST a la API
+     * @param {string} endpoint - Punto final de la API
+     * @param {TData} data - Datos a enviar en la petición
+     * @param {AxiosRequestConfig} [config] - Configuración adicional para la petición
+     * @returns {Promise<ApiResponse<T>>} Respuesta de la API
+     * @template T - Tipo de datos esperado en la respuesta
+     * @template TData - Tipo de datos a enviar en la petición
+     */
+    postAsync<T, TData = Record<string, unknown>>(endpoint: string, data: TData, config?: AxiosRequestConfig): Promise<ApiResponse<T>>;
+    /**
+     * Realiza una petición PUT a la API
+     * @param {string} endpoint - Punto final de la API
+     * @param {TData} data - Datos a enviar en la petición
+     * @param {AxiosRequestConfig} [config] - Configuración adicional para la petición
+     * @returns {Promise<ApiResponse<T>>} Respuesta de la API
+     * @template T - Tipo de datos esperado en la respuesta
+     * @template TData - Tipo de datos a enviar en la petición
+     */
+    putAsync<T, TData = Record<string, unknown>>(endpoint: string, data: TData, config?: AxiosRequestConfig): Promise<ApiResponse<T>>;
+    /**
+     * Realiza una petición DELETE a la API
+     * @param {string} endpoint - Punto final de la API
+     * @param {AxiosRequestConfig} [config] - Configuración adicional para la petición
+     * @returns {Promise<ApiResponse<boolean>>} Respuesta de la API
+     */
+    deleteAsync(endpoint: string, config?: AxiosRequestConfig): Promise<ApiResponse<boolean>>;
+    /**
+     * Realiza una petición PATCH a la API
+     * @param {string} endpoint - Punto final de la API
+     * @param {TData} data - Datos a enviar en la petición
+     * @param {AxiosRequestConfig} [config] - Configuración adicional para la petición
+     * @returns {Promise<ApiResponse<T>>} Respuesta de la API
+     * @template T - Tipo de datos esperado en la respuesta
+     * @template TData - Tipo de datos a enviar en la petición
+     */
+    patchAsync<T, TData = Record<string, unknown>>(endpoint: string, data: TData, config?: AxiosRequestConfig): Promise<ApiResponse<T>>;
+}

package/dist/types/http/fiscalapi-http-client.interface.d.ts

@@ -0,0 +1,80 @@
+import { AxiosRequestConfig } from 'axios';
+import { ApiResponse } from '../common/api-response';
+/**
+ * Métodos HTTP soportados
+ */
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+/**
+ * Opciones para una petición HTTP genérica
+ * @template TData - Tipo de datos de entrada (opcional)
+ */
+export interface RequestOptions<TData = any> {
+    /** Datos para enviar en el cuerpo de la petición (opcional) */
+    data?: TData;
+    /** Parámetros de consulta (query string) (opcional) */
+    queryParams?: Record<string, string>;
+    /** Configuración adicional para Axios (opcional) */
+    config?: AxiosRequestConfig;
+    /** Transformador de respuesta personalizado (opcional) */
+    responseTransformer?: <T>(response: any) => T;
+}
+/**
+ * Interfaz para el cliente HTTP de FiscalAPI
+ */
+export interface IFiscalapiHttpClient {
+    /**
+     * Realiza una petición GET a la API
+     * @param endpoint - Punto final de la API
+     * @param config - Configuración adicional para la petición
+     * @returns Respuesta de la API
+     */
+    getAsync<T>(endpoint: string, config?: AxiosRequestConfig): Promise<ApiResponse<T>>;
+    /**
+     * Realiza una petición GET por ID a la API
+     * @param endpoint - Punto final de la API con ID
+     * @param config - Configuración adicional para la petición
+     * @returns Respuesta de la API
+     */
+    getByIdAsync<T>(endpoint: string, config?: AxiosRequestConfig): Promise<ApiResponse<T>>;
+    /**
+     * Realiza una petición POST a la API
+     * @param endpoint - Punto final de la API
+     * @param data - Datos a enviar en la petición
+     * @param config - Configuración adicional para la petición
+     * @returns Respuesta de la API
+     */
+    postAsync<T, TData = Record<string, unknown>>(endpoint: string, data: TData, config?: AxiosRequestConfig): Promise<ApiResponse<T>>;
+    /**
+     * Realiza una petición PUT a la API
+     * @param endpoint - Punto final de la API
+     * @param data - Datos a enviar en la petición
+     * @param config - Configuración adicional para la petición
+     * @returns Respuesta de la API
+     */
+    putAsync<T, TData = Record<string, unknown>>(endpoint: string, data: TData, config?: AxiosRequestConfig): Promise<ApiResponse<T>>;
+    /**
+     * Realiza una petición DELETE a la API
+     * @param endpoint - Punto final de la API
+     * @param config - Configuración adicional para la petición
+     * @returns Respuesta de la API
+     */
+    deleteAsync(endpoint: string, config?: AxiosRequestConfig): Promise<ApiResponse<boolean>>;
+    /**
+     * Realiza una petición PATCH a la API
+     * @param endpoint - Punto final de la API
+     * @param data - Datos a enviar en la petición
+     * @param config - Configuración adicional para la petición
+     * @returns Respuesta de la API
+     */
+    patchAsync<T, TData = Record<string, unknown>>(endpoint: string, data: TData, config?: AxiosRequestConfig): Promise<ApiResponse<T>>;
+    /**
+     * Ejecuta una petición HTTP genérica con control completo sobre los parámetros
+     * @param method - Método HTTP a utilizar
+     * @param endpoint - Punto final de la API
+     * @param options - Opciones de la petición
+     * @returns Respuesta de la API
+     * @template TResult - Tipo de datos esperado en la respuesta
+     * @template TData - Tipo de datos a enviar en la petición (opcional)
+     */
+    executeRequest<TResult, TData = any>(method: HttpMethod, endpoint: string, options?: RequestOptions<TData>): Promise<ApiResponse<TResult>>;
+}