fiscalapi 1.0.0

package/dist/esm/services/base-fiscalapi-service.js

@@ -0,0 +1,166 @@
+/**
+ * Implementación base de un servicio de FiscalAPI
+ * @template T - Tipo de DTO que maneja el servicio
+ */
+export class BaseFiscalapiService {
+    /**
+     * Crea una nueva instancia del servicio base
+     * @param {IFiscalapiHttpClient} httpClient - Cliente HTTP
+     * @param {string} resourcePath - Ruta del recurso en la API
+     * @param {string} apiVersion - Versión de la API
+     */
+    constructor(httpClient, resourcePath, apiVersion) {
+        if (!httpClient)
+            throw new Error('httpClient no puede ser nulo o indefinido');
+        if (!resourcePath)
+            throw new Error('resourcePath no puede ser nulo o indefinido');
+        if (!apiVersion)
+            throw new Error('apiVersion no puede ser nulo o indefinido');
+        this.httpClient = httpClient;
+        this.resourcePath = resourcePath;
+        this.apiVersion = apiVersion;
+    }
+    /**
+     * Construye una URL de endpoint de API
+     * @param {string} [path=''] - Segmento de ruta opcional
+     * @param {Record<string, string>} [queryParams] - Parámetros de consulta opcionales
+     * @returns {string} URL del endpoint
+     * @protected
+     */
+    buildEndpoint(path = '', queryParams) {
+        let baseEndpoint = `api/${this.apiVersion}/${this.resourcePath}`;
+        if (path) {
+            baseEndpoint += `/${path}`;
+        }
+        if (queryParams && Object.keys(queryParams).length > 0) {
+            const queryString = Object.entries(queryParams)
+                .filter(([key]) => key)
+                .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
+                .join('&');
+            baseEndpoint += `?${queryString}`;
+        }
+        return baseEndpoint;
+    }
+    /**
+     * Convierte los parámetros de consulta a un objeto compatible con la configuración de Axios
+     * @param {Record<string, string>} queryParams - Parámetros de consulta
+     * @returns {AxiosRequestConfig} Configuración de Axios con los parámetros
+     * @protected
+     */
+    createConfigWithParams(queryParams) {
+        return queryParams ? { params: queryParams } : {};
+    }
+    /**
+     * 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
+     */
+    async executeRequest(options) {
+        try {
+            // Extraer opciones
+            const { method, path = '', id, data, queryParams = {}, config = {}, responseTransformer } = options;
+            // Construir el endpoint completo
+            let endpoint = '';
+            // Si se proporciona un ID, lo añadimos a la ruta
+            if (id) {
+                endpoint = this.buildEndpoint(`${path ? `${path}/` : ''}${id}`, queryParams);
+            }
+            else if (path) {
+                endpoint = this.buildEndpoint(path, queryParams);
+            }
+            else {
+                endpoint = this.buildEndpoint('', queryParams);
+            }
+            // Ejecutar la petición a través del cliente HTTP
+            return this.httpClient.executeRequest(method, endpoint, {
+                data,
+                config,
+                responseTransformer
+            });
+        }
+        catch (error) {
+            // Manejo centralizado de errores
+            console.error(`Error al ejecutar petición personalizada:`, error);
+            // Convertir el error en una respuesta de error estándar
+            if (error instanceof Error) {
+                const errorResponse = {
+                    succeeded: false,
+                    data: null,
+                    message: `Error al ejecutar petición: ${error.message}`,
+                    details: JSON.stringify({
+                        code: 'REQUEST_ERROR',
+                        message: error.message
+                    }),
+                    httpStatusCode: 500
+                };
+                return errorResponse;
+            }
+            throw error;
+        }
+    }
+    /**
+     * @inheritdoc
+     */
+    async getList(pageNumber, pageSize) {
+        const queryParams = {
+            PageNumber: pageNumber.toString(),
+            PageSize: pageSize.toString()
+        };
+        return this.executeRequest({
+            method: 'GET',
+            queryParams
+        });
+    }
+    /**
+     * @inheritdoc
+     */
+    async getById(id, details = false) {
+        const queryParams = details ? { details: details.toString().toLowerCase() } : undefined;
+        return this.executeRequest({
+            method: 'GET',
+            id,
+            queryParams
+        });
+    }
+    /**
+     * @inheritdoc
+     */
+    async create(model) {
+        return this.executeRequest({
+            method: 'POST',
+            data: model
+        });
+    }
+    /**
+     * @inheritdoc
+     */
+    async update(model) {
+        return this.executeRequest({
+            method: 'PUT',
+            id: model.id,
+            data: model
+        });
+    }
+    /**
+     * @inheritdoc
+     */
+    async delete(id) {
+        return this.executeRequest({
+            method: 'DELETE',
+            id
+        });
+    }
+    /**
+     * @inheritdoc
+     */
+    async search(searchParams) {
+        return this.executeRequest({
+            method: 'GET',
+            path: 'search',
+            queryParams: searchParams
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-fiscalapi-service.js","sourceRoot":"","sources":["../../../src/services/base-fiscalapi-service.ts"],"names":[],"mappings":"AAOA;;;GAGG;AACH,MAAM,OAAgB,oBAAoB;IAUxC;;;;;OAKG;IACH,YAAY,UAAgC,EAAE,YAAoB,EAAE,UAAkB;QACpF,IAAI,CAAC,UAAU;YAAE,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;QAC9E,IAAI,CAAC,YAAY;YAAE,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;QAClF,IAAI,CAAC,UAAU;YAAE,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;QAE9E,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;QACjC,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;IAC/B,CAAC;IAED;;;;;;OAMG;IACO,aAAa,CAAC,OAAe,EAAE,EAAE,WAAoC;QAC7E,IAAI,YAAY,GAAG,OAAO,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;QAEjE,IAAI,IAAI,EAAE,CAAC;YACT,YAAY,IAAI,IAAI,IAAI,EAAE,CAAC;QAC7B,CAAC;QAED,IAAI,WAAW,IAAI,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACvD,MAAM,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;iBAC5C,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC;iBACtB,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,GAAG,kBAAkB,CAAC,GAAG,CAAC,IAAI,kBAAkB,CAAC,KAAK,CAAC,EAAE,CAAC;iBAChF,IAAI,CAAC,GAAG,CAAC,CAAC;YAEb,YAAY,IAAI,IAAI,WAAW,EAAE,CAAC;QACpC,CAAC;QAED,OAAO,YAAY,CAAC;IACtB,CAAC;IAED;;;;;OAKG;IACO,sBAAsB,CAAC,WAAoC;QACnE,OAAO,WAAW,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IACpD,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,cAAc,CAClB,OAA8B;QAE9B,IAAI,CAAC;YACH,mBAAmB;YACnB,MAAM,EACJ,MAAM,EACN,IAAI,GAAG,EAAE,EACT,EAAE,EACF,IAAI,EACJ,WAAW,GAAG,EAAE,EAChB,MAAM,GAAG,EAAE,EACX,mBAAmB,EACpB,GAAG,OAAO,CAAC;YAEZ,iCAAiC;YACjC,IAAI,QAAQ,GAAG,EAAE,CAAC;YAElB,iDAAiD;YACjD,IAAI,EAAE,EAAE,CAAC;gBACP,QAAQ,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,WAAW,CAAC,CAAC;YAC/E,CAAC;iBAAM,IAAI,IAAI,EAAE,CAAC;gBAChB,QAAQ,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;YACnD,CAAC;iBAAM,CAAC;gBACN,QAAQ,GAAG,IAAI,CAAC,aAAa,CAAC,EAAE,EAAE,WAAW,CAAC,CAAC;YACjD,CAAC;YAED,iDAAiD;YACjD,OAAO,IAAI,CAAC,UAAU,CAAC,cAAc,CACnC,MAAM,EACN,QAAQ,EACR;gBACE,IAAI;gBACJ,MAAM;gBACN,mBAAmB;aACpB,CACF,CAAC;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,iCAAiC;YACjC,OAAO,CAAC,KAAK,CAAC,2CAA2C,EAAE,KAAK,CAAC,CAAC;YAElE,wDAAwD;YACxD,IAAI,KAAK,YAAY,KAAK,EAAE,CAAC;gBAC3B,MAAM,aAAa,GAAyB;oBAC1C,SAAS,EAAE,KAAK;oBAChB,IAAI,EAAE,IAA0B;oBAChC,OAAO,EAAE,+BAA+B,KAAK,CAAC,OAAO,EAAE;oBACvD,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC;wBACtB,IAAI,EAAE,eAAe;wBACrB,OAAO,EAAE,KAAK,CAAC,OAAO;qBACvB,CAAC;oBACF,cAAc,EAAE,GAAG;iBACpB,CAAC;gBAEF,OAAO,aAAa,CAAC;YACvB,CAAC;YAED,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAID;;OAEG;IACH,KAAK,CAAC,OAAO,CAAC,UAAkB,EAAE,QAAgB;QAChD,MAAM,WAAW,GAAG;YAClB,UAAU,EAAE,UAAU,CAAC,QAAQ,EAAE;YACjC,QAAQ,EAAE,QAAQ,CAAC,QAAQ,EAAE;SAC9B,CAAC;QAEF,OAAO,IAAI,CAAC,cAAc,CAAe;YACvC,MAAM,EAAE,KAAK;YACb,WAAW;SACZ,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,OAAO,CAAC,EAAU,EAAE,UAAmB,KAAK;QAChD,MAAM,WAAW,GAAG,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,QAAQ,EAAE,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;QAExF,OAAO,IAAI,CAAC,cAAc,CAAI;YAC5B,MAAM,EAAE,KAAK;YACb,EAAE;YACF,WAAW;SACZ,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,MAAM,CAAC,KAAQ;QACnB,OAAO,IAAI,CAAC,cAAc,CAAO;YAC/B,MAAM,EAAE,MAAM;YACd,IAAI,EAAE,KAAK;SACZ,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,MAAM,CAAC,KAAQ;QACnB,OAAO,IAAI,CAAC,cAAc,CAAO;YAC/B,MAAM,EAAE,KAAK;YACb,EAAE,EAAE,KAAK,CAAC,EAAE;YACZ,IAAI,EAAE,KAAK;SACZ,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,MAAM,CAAC,EAAU;QACrB,OAAO,IAAI,CAAC,cAAc,CAAU;YAClC,MAAM,EAAE,QAAQ;YAChB,EAAE;SACH,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,MAAM,CAAC,YAAoC;QAC/C,OAAO,IAAI,CAAC,cAAc,CAAe;YACvC,MAAM,EAAE,KAAK;YACb,IAAI,EAAE,QAAQ;YACd,WAAW,EAAE,YAAY;SAC1B,CAAC,CAAC;IACL,CAAC;CACF","sourcesContent":["import { AxiosRequestConfig } from 'axios';\nimport { BaseDto } from '../common/base-dto';\nimport { ApiResponse } from '../common/api-response';\nimport { PagedList } from '../common/paged-list';\nimport { IFiscalapiHttpClient, HttpMethod } from '../http/fiscalapi-http-client.interface';\nimport { IFiscalapiService, OperationOptions, RequestOptions } from '../abstractions/fiscalapi-service.interface';\n\n/**\n * Implementación base de un servicio de FiscalAPI\n * @template T - Tipo de DTO que maneja el servicio\n */\nexport abstract class BaseFiscalapiService<T extends BaseDto> implements IFiscalapiService<T> {\n  /** Cliente HTTP */\n  protected readonly httpClient: IFiscalapiHttpClient;\n  \n  /** Ruta del recurso */\n  protected readonly resourcePath: string;\n  \n  /** Versión de la API */\n  protected readonly apiVersion: string;\n\n  /**\n   * Crea una nueva instancia del servicio base\n   * @param {IFiscalapiHttpClient} httpClient - Cliente HTTP\n   * @param {string} resourcePath - Ruta del recurso en la API\n   * @param {string} apiVersion - Versión de la API\n   */\n  constructor(httpClient: IFiscalapiHttpClient, resourcePath: string, apiVersion: string) {\n    if (!httpClient) throw new Error('httpClient no puede ser nulo o indefinido');\n    if (!resourcePath) throw new Error('resourcePath no puede ser nulo o indefinido');\n    if (!apiVersion) throw new Error('apiVersion no puede ser nulo o indefinido');\n    \n    this.httpClient = httpClient;\n    this.resourcePath = resourcePath;\n    this.apiVersion = apiVersion;\n  }\n\n  /**\n   * Construye una URL de endpoint de API\n   * @param {string} [path=''] - Segmento de ruta opcional\n   * @param {Record<string, string>} [queryParams] - Parámetros de consulta opcionales\n   * @returns {string} URL del endpoint\n   * @protected\n   */\n  protected buildEndpoint(path: string = '', queryParams?: Record<string, string>): string {\n    let baseEndpoint = `api/${this.apiVersion}/${this.resourcePath}`;\n    \n    if (path) {\n      baseEndpoint += `/${path}`;\n    }\n    \n    if (queryParams && Object.keys(queryParams).length > 0) {\n      const queryString = Object.entries(queryParams)\n        .filter(([key]) => key)\n        .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)\n        .join('&');\n      \n      baseEndpoint += `?${queryString}`;\n    }\n    \n    return baseEndpoint;\n  }\n\n  /**\n   * Convierte los parámetros de consulta a un objeto compatible con la configuración de Axios\n   * @param {Record<string, string>} queryParams - Parámetros de consulta\n   * @returns {AxiosRequestConfig} Configuración de Axios con los parámetros\n   * @protected\n   */\n  protected createConfigWithParams(queryParams?: Record<string, string>): AxiosRequestConfig {\n    return queryParams ? { params: queryParams } : {};\n  }\n\n  /**\n   * Ejecuta una petición HTTP personalizada con máxima flexibilidad\n   * @param {RequestOptions<TData>} options - Opciones para la petición\n   * @returns {Promise<ApiResponse<TResult>>} Resultado de la petición\n   * @template TResult - Tipo de resultado esperado\n   * @template TData - Tipo de datos de entrada\n   */\n  async executeRequest<TResult, TData = any>(\n    options: RequestOptions<TData>\n  ): Promise<ApiResponse<TResult>> {\n    try {\n      // Extraer opciones\n      const { \n        method, \n        path = '', \n        id, \n        data, \n        queryParams = {}, \n        config = {},\n        responseTransformer\n      } = options;\n      \n      // Construir el endpoint completo\n      let endpoint = '';\n      \n      // Si se proporciona un ID, lo añadimos a la ruta\n      if (id) {\n        endpoint = this.buildEndpoint(`${path ? `${path}/` : ''}${id}`, queryParams);\n      } else if (path) {\n        endpoint = this.buildEndpoint(path, queryParams);\n      } else {\n        endpoint = this.buildEndpoint('', queryParams);\n      }\n      \n      // Ejecutar la petición a través del cliente HTTP\n      return this.httpClient.executeRequest<TResult, TData>(\n        method,\n        endpoint,\n        {\n          data,\n          config,\n          responseTransformer\n        }\n      );\n    } catch (error) {\n      // Manejo centralizado de errores\n      console.error(`Error al ejecutar petición personalizada:`, error);\n      \n      // Convertir el error en una respuesta de error estándar\n      if (error instanceof Error) {\n        const errorResponse: ApiResponse<TResult> = {\n          succeeded: false,\n          data: null as unknown as TResult,\n          message: `Error al ejecutar petición: ${error.message}`,\n          details: JSON.stringify({\n            code: 'REQUEST_ERROR',\n            message: error.message\n          }),\n          httpStatusCode: 500\n        };\n        \n        return errorResponse;\n      }\n      \n      throw error;\n    }\n  }\n  \n \n\n  /**\n   * @inheritdoc\n   */\n  async getList(pageNumber: number, pageSize: number): Promise<ApiResponse<PagedList<T>>> {\n    const queryParams = {\n      PageNumber: pageNumber.toString(),\n      PageSize: pageSize.toString()\n    };\n    \n    return this.executeRequest<PagedList<T>>({\n      method: 'GET',\n      queryParams\n    });\n  }\n\n  /**\n   * @inheritdoc\n   */\n  async getById(id: string, details: boolean = false): Promise<ApiResponse<T>> {\n    const queryParams = details ? { details: details.toString().toLowerCase() } : undefined;\n    \n    return this.executeRequest<T>({\n      method: 'GET',\n      id,\n      queryParams\n    });\n  }\n\n  /**\n   * @inheritdoc\n   */\n  async create(model: T): Promise<ApiResponse<T>> {\n    return this.executeRequest<T, T>({\n      method: 'POST',\n      data: model\n    });\n  }\n\n  /**\n   * @inheritdoc\n   */\n  async update(model: T): Promise<ApiResponse<T>> {\n    return this.executeRequest<T, T>({\n      method: 'PUT',\n      id: model.id,\n      data: model\n    });\n  }\n\n  /**\n   * @inheritdoc\n   */\n  async delete(id: string): Promise<ApiResponse<boolean>> {\n    return this.executeRequest<boolean>({\n      method: 'DELETE',\n      id\n    });\n  }\n\n  /**\n   * @inheritdoc\n   */\n  async search(searchParams: Record<string, string>): Promise<ApiResponse<PagedList<T>>> {\n    return this.executeRequest<PagedList<T>>({\n      method: 'GET',\n      path: 'search',\n      queryParams: searchParams\n    });\n  }\n}"]}

package/dist/esm/services/catalog-service.js

@@ -0,0 +1,47 @@
+import { BaseFiscalapiService } from './base-fiscalapi-service';
+/**
+ * Implementación del servicio de catálogos
+ */
+export class CatalogService extends BaseFiscalapiService {
+    /**
+     * Crea una nueva instancia del servicio de catálogos
+     * @param {IFiscalapiHttpClient} httpClient - Cliente HTTP
+     * @param {string} apiVersion - Versión de la API
+     */
+    constructor(httpClient, apiVersion) {
+        super(httpClient, 'catalogs', apiVersion);
+    }
+    /**
+    * Recupera un registro de un catálogo por catalogName y id.
+    *
+    * @param catalogName - Nombre del catálogo
+    * @param id - Id del registro en el catalogName
+    * @returns Promise que resuelve en una respuesta API con CatalogDto
+    */
+    async getRecordById(catalogName, id) {
+        const path = `${catalogName}/key/${id}`;
+        const endpoint = this.buildEndpoint(path);
+        // api/v4/catalogs/<catalogName>/key/<id>
+        return this.httpClient.getAsync(endpoint);
+    }
+    /**
+    * Busca en un catálogo.
+    *
+    * @param catalogName - Catalog name. Must be a catalog retrieved from getList()
+    * @param searchText - Criterio de búsqueda. Debe tener 4 caracteres de longitud como mínimo.
+    * @param pageNumber - Numero de pagina a recuperar (default: 1)
+    * @param pageSize - Tamaño de la página entre 1 y 100 registros por página (default: 50)
+    * @returns Promise que resuelve en una respuesta API con lista paginada de CatalogDto
+    */
+    async searchCatalog(catalogName, searchText, pageNumber = 1, pageSize = 50) {
+        const path = `${catalogName}/${searchText}`;
+        const queryParams = {
+            pageNumber: pageNumber.toString(),
+            pageSize: pageSize.toString()
+        };
+        const endpoint = this.buildEndpoint(path, queryParams);
+        const response = await this.httpClient.getAsync(endpoint);
+        return response;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/services/fiscalapi-client.js

@@ -0,0 +1,63 @@
+import { FiscalapiHttpClientFactory } from '../http/fiscalapi-http-client-factory';
+import { ApiKeyService } from './api-key-service';
+import { CatalogService } from './catalog-service';
+import { InvoiceService } from './invoice-service';
+import { PersonService } from './person-service';
+import { ProductService } from './product-service';
+import { TaxFileService } from './tax-file-service';
+/**
+ * Cliente principal para FiscalAPI
+ */
+export class FiscalapiClient {
+    /**
+     * Crea una nueva instancia del cliente de FiscalAPI
+     * @param {FiscalapiSettings} settings - Configuración
+     * @private
+     */
+    constructor(settings) {
+        // Crea el cliente HTTP
+        const httpClient = FiscalapiHttpClientFactory.create(settings);
+        const apiVersion = settings.apiVersion || 'v4';
+        // Inicializa los servicios
+        this.invoices = new InvoiceService(httpClient, apiVersion);
+        this.products = new ProductService(httpClient, apiVersion);
+        this.persons = new PersonService(httpClient, apiVersion);
+        this.apiKeys = new ApiKeyService(httpClient, apiVersion);
+        this.catalogs = new CatalogService(httpClient, apiVersion);
+        this.taxFiles = new TaxFileService(httpClient, apiVersion);
+    }
+    /**
+     * Crea una nueva instancia del cliente de FiscalAPI
+     * @param {FiscalapiSettings} settings - Configuración
+     * @returns {IFiscalapiClient} Instancia del cliente de FiscalAPI
+     */
+    static create(settings) {
+        if (!settings) {
+            throw new Error('La configuración no puede ser nula o indefinida');
+        }
+        // Valida la configuración
+        FiscalapiClient.validateSettings(settings);
+        // Establece valores predeterminados para configuraciones opcionales
+        settings.apiVersion = settings.apiVersion || 'v4';
+        settings.timeZone = settings.timeZone || 'America/Mexico_City';
+        settings.debug = settings.debug || false;
+        return new FiscalapiClient(settings);
+    }
+    /**
+     * Valida la configuración
+     * @param {FiscalapiSettings} settings - Configuración
+     * @private
+     */
+    static validateSettings(settings) {
+        if (!settings.apiUrl) {
+            throw new Error('apiUrl es requerido');
+        }
+        if (!settings.apiKey) {
+            throw new Error('apiKey es requerido');
+        }
+        if (!settings.tenant) {
+            throw new Error('tenant es requerido');
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/services/invoice-service.js

@@ -0,0 +1,112 @@
+import { BaseFiscalapiService } from './base-fiscalapi-service';
+/**
+ * Implementación del servicio de facturas
+ */
+export class InvoiceService extends BaseFiscalapiService {
+    /**
+     * Crea una nueva instancia del servicio de facturas
+     * @param {IFiscalapiHttpClient} httpClient - Cliente HTTP
+     * @param {string} apiVersion - Versión de la API
+     */
+    constructor(httpClient, apiVersion) {
+        super(httpClient, 'invoices', apiVersion);
+        this.INCOME_ENDPOINT = 'income';
+        this.CREDIT_NOTE_ENDPOINT = 'credit-note';
+        this.PAYMENT_ENDPOINT = 'payment';
+    }
+    /**
+     * @inheritdoc
+     */
+    async create(requestModel) {
+        if (!requestModel) {
+            throw new Error('requestModel cannot be null');
+        }
+        let endpoint;
+        switch (requestModel.typeCode) {
+            case 'I':
+                endpoint = this.INCOME_ENDPOINT;
+                break;
+            case 'E':
+                endpoint = this.CREDIT_NOTE_ENDPOINT;
+                break;
+            case 'P':
+                endpoint = this.PAYMENT_ENDPOINT;
+                break;
+            default:
+                throw new Error(`Unsupported invoice type: ${requestModel.typeCode}`);
+        }
+        return await this.executeRequest({
+            path: endpoint,
+            data: requestModel,
+            method: 'POST',
+        });
+    }
+    /**
+     * Cancela una factura
+     * @param {CancelInvoiceRequest} request - Solicitud para cancelar factura
+     * @returns {Promise<ApiResponse<CancelInvoiceResponse>>} Respuesta de la cancelación
+     */
+    async cancel(request) {
+        if (!request) {
+            throw new Error('request cannot be null');
+        }
+        return await this.executeRequest({
+            data: request,
+            method: 'DELETE',
+        });
+    }
+    /**
+     * Obtiene el PDF de una factura
+     * @param {CreatePdfRequest} request - Solicitud para crear PDF
+     * @returns {Promise<ApiResponse<FileResponse>>} Respuesta con el archivo PDF
+     */
+    async getPdf(request) {
+        if (!request) {
+            throw new Error('request cannot be null');
+        }
+        return await this.executeRequest({
+            path: 'pdf',
+            data: request,
+            method: 'POST',
+        });
+    }
+    /**
+     * Obtiene el XML de una factura
+     * @param {string} id - ID de la factura
+     * @returns {Promise<ApiResponse<FileResponse>>} Respuesta con el archivo XML
+     */
+    async getXml(id) {
+        if (!id || id.trim() === '') {
+            throw new Error('id cannot be null or empty');
+        }
+        return await this.executeRequest({
+            path: `${id}/xml`,
+            method: 'GET',
+        });
+    }
+    /**
+     * Envía una factura por correo electrónico
+     * @param {SendInvoiceRequest} request - Solicitud para enviar factura
+     * @returns {Promise<ApiResponse<boolean>>} Resultado de la operación
+     */
+    async send(request) {
+        return await this.executeRequest({
+            path: 'send',
+            data: request,
+            method: 'POST',
+        });
+    }
+    /**
+     * Obtiene el estado de una factura
+     * @param {InvoiceStatusRequest} request - Solicitud para consultar estado
+     * @returns {Promise<ApiResponse<InvoiceStatusResponse>>} Respuesta con el estado de la factura
+     */
+    async getStatus(request) {
+        return await this.executeRequest({
+            path: 'status',
+            data: request,
+            method: 'POST',
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"invoice-service.js","sourceRoot":"","sources":["../../../src/services/invoice-service.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAYhE;;GAEG;AACH,MAAM,OAAO,cAAe,SAAQ,oBAA6B;IAK/D;;;;OAIG;IACH,YAAY,UAAgC,EAAE,UAAkB;QAC9D,KAAK,CAAC,UAAU,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC;QAV3B,oBAAe,GAAG,QAAQ,CAAC;QAC3B,yBAAoB,GAAG,aAAa,CAAC;QACrC,qBAAgB,GAAG,SAAS,CAAC;IAS9C,CAAC;IAED;;OAEG;IACO,KAAK,CAAC,MAAM,CAAC,YAAqB;QAC1C,IAAI,CAAC,YAAY,EAAE,CAAC;YAClB,MAAM,IAAI,KAAK,CAAC,6BAA6B,CAAC,CAAC;QACjD,CAAC;QAED,IAAI,QAAgB,CAAC;QAErB,QAAQ,YAAY,CAAC,QAAQ,EAAE,CAAC;YAC9B,KAAK,GAAG;gBACN,QAAQ,GAAG,IAAI,CAAC,eAAe,CAAC;gBAChC,MAAM;YACR,KAAK,GAAG;gBACN,QAAQ,GAAG,IAAI,CAAC,oBAAoB,CAAC;gBACrC,MAAM;YACR,KAAK,GAAG;gBACN,QAAQ,GAAG,IAAI,CAAC,gBAAgB,CAAC;gBACjC,MAAM;YACR;gBACE,MAAM,IAAI,KAAK,CAAC,6BAA6B,YAAY,CAAC,QAAQ,EAAE,CAAC,CAAC;QAC1E,CAAC;QAEC,OAAO,MAAM,IAAI,CAAC,cAAc,CAAmB;YACjD,IAAI,EAAC,QAAQ;YACb,IAAI,EAAC,YAAY;YACjB,MAAM,EAAC,MAAM;SACd,CAAC,CAAC;IACP,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,MAAM,CAAC,OAA6B;QACxC,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAC;QAC5C,CAAC;QAED,OAAO,MAAM,IAAI,CAAC,cAAc,CAA8C;YAC5E,IAAI,EAAC,OAAO;YACZ,MAAM,EAAC,QAAQ;SAChB,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,MAAM,CAAC,OAAyB;QACpC,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAC;QAC5C,CAAC;QACD,OAAO,MAAM,IAAI,CAAC,cAAc,CAAiC;YAC/D,IAAI,EAAC,KAAK;YACV,IAAI,EAAC,OAAO;YACZ,MAAM,EAAC,MAAM;SACd,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,MAAM,CAAC,EAAU;QAErB,IAAI,CAAC,EAAE,IAAI,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;YAC5B,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC;QAChD,CAAC;QAED,OAAO,MAAM,IAAI,CAAC,cAAc,CAAuB;YACrD,IAAI,EAAC,GAAG,EAAE,MAAM;YAChB,MAAM,EAAE,KAAK;SACd,CAAC,CAAC;IAEL,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,IAAI,CAAC,OAA2B;QACpC,OAAO,MAAM,IAAI,CAAC,cAAc,CAA8B;YAC5D,IAAI,EAAC,MAAM;YACX,IAAI,EAAC,OAAO;YACZ,MAAM,EAAC,MAAM;SACd,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,SAAS,CAAC,OAA6B;QACvC,OAAO,MAAM,IAAI,CAAC,cAAc,CAA8C;YAC9E,IAAI,EAAC,QAAQ;YACb,IAAI,EAAC,OAAO;YACZ,MAAM,EAAC,MAAM;SACd,CAAC,CAAC;IACP,CAAC;CACF","sourcesContent":["import { IFiscalapiHttpClient } from '../http/fiscalapi-http-client.interface';\nimport { ApiResponse } from '../common/api-response';\nimport { FileResponse } from '../common/file-response';\nimport { BaseFiscalapiService } from './base-fiscalapi-service';\nimport { IInvoiceService } from '../abstractions/invoice-service.interface';\nimport { \n  Invoice, \n  CancelInvoiceRequest, \n  CancelInvoiceResponse, \n  CreatePdfRequest, \n  SendInvoiceRequest,\n  InvoiceStatusRequest,\n  InvoiceStatusResponse\n} from '../models/invoice';\n\n/**\n * Implementación del servicio de facturas\n */\nexport class InvoiceService extends BaseFiscalapiService<Invoice> implements IInvoiceService {\n  private readonly INCOME_ENDPOINT = 'income';\n  private readonly CREDIT_NOTE_ENDPOINT = 'credit-note';\n  private readonly PAYMENT_ENDPOINT = 'payment';\n\n  /**\n   * Crea una nueva instancia del servicio de facturas\n   * @param {IFiscalapiHttpClient} httpClient - Cliente HTTP\n   * @param {string} apiVersion - Versión de la API\n   */\n  constructor(httpClient: IFiscalapiHttpClient, apiVersion: string) {\n    super(httpClient, 'invoices', apiVersion);\n  }\n\n  /**\n   * @inheritdoc\n   */\n   override async create(requestModel: Invoice): Promise<ApiResponse<Invoice>> {\n    if (!requestModel) {\n      throw new Error('requestModel cannot be null');\n    }\n\n    let endpoint: string;\n\n    switch (requestModel.typeCode) {\n      case 'I':\n        endpoint = this.INCOME_ENDPOINT;\n        break;\n      case 'E':\n        endpoint = this.CREDIT_NOTE_ENDPOINT;\n        break;\n      case 'P':\n        endpoint = this.PAYMENT_ENDPOINT;\n        break;\n      default:\n        throw new Error(`Unsupported invoice type: ${requestModel.typeCode}`);\n    }\n\n      return await this.executeRequest<Invoice, Invoice>({\n        path:endpoint,\n        data:requestModel,\n        method:'POST',\n      });\n  }\n\n  /**\n   * Cancela una factura\n   * @param {CancelInvoiceRequest} request - Solicitud para cancelar factura\n   * @returns {Promise<ApiResponse<CancelInvoiceResponse>>} Respuesta de la cancelación\n   */\n  async cancel(request: CancelInvoiceRequest): Promise<ApiResponse<CancelInvoiceResponse>> {\n    if (!request) {\n      throw new Error('request cannot be null');\n    }\n\n    return await this.executeRequest<CancelInvoiceResponse, CancelInvoiceRequest>({\n      data:request,\n      method:'DELETE',\n    });\n  }\n\n  /**\n   * Obtiene el PDF de una factura\n   * @param {CreatePdfRequest} request - Solicitud para crear PDF\n   * @returns {Promise<ApiResponse<FileResponse>>} Respuesta con el archivo PDF\n   */\n  async getPdf(request: CreatePdfRequest): Promise<ApiResponse<FileResponse>> {\n    if (!request) {\n      throw new Error('request cannot be null');\n    }\n    return await this.executeRequest<FileResponse, CreatePdfRequest>({\n      path:'pdf',\n      data:request,\n      method:'POST',\n    });\n  }\n\n  /**\n   * Obtiene el XML de una factura\n   * @param {string} id - ID de la factura\n   * @returns {Promise<ApiResponse<FileResponse>>} Respuesta con el archivo XML\n   */\n  async getXml(id: string): Promise<ApiResponse<FileResponse>> {\n\n    if (!id || id.trim() === '') {\n      throw new Error('id cannot be null or empty');\n    }\n\n    return await this.executeRequest<FileResponse, string>({\n      path:`${id}/xml`,\n      method: 'GET',\n    });\n\n  }\n\n  /**\n   * Envía una factura por correo electrónico\n   * @param {SendInvoiceRequest} request - Solicitud para enviar factura\n   * @returns {Promise<ApiResponse<boolean>>} Resultado de la operación\n   */\n  async send(request: SendInvoiceRequest): Promise<ApiResponse<boolean>> {\n    return await this.executeRequest<boolean, SendInvoiceRequest>({\n      path:'send',\n      data:request,\n      method:'POST',\n    });\n  }\n\n  /**\n   * Obtiene el estado de una factura\n   * @param {InvoiceStatusRequest} request - Solicitud para consultar estado\n   * @returns {Promise<ApiResponse<InvoiceStatusResponse>>} Respuesta con el estado de la factura\n   */\n  async getStatus(request: InvoiceStatusRequest): Promise<ApiResponse<InvoiceStatusResponse>> {\n        return await this.executeRequest<InvoiceStatusResponse, InvoiceStatusRequest>({\n        path:'status',\n        data:request,\n        method:'POST',\n      });\n  }\n}"]}

package/dist/esm/services/person-service.js

@@ -0,0 +1,15 @@
+import { BaseFiscalapiService } from './base-fiscalapi-service';
+/**
+ * Implementación del servicio de personas
+ */
+export class PersonService extends BaseFiscalapiService {
+    /**
+     * Crea una nueva instancia del servicio de personas
+     * @param {IFiscalapiHttpClient} httpClient - Cliente HTTP
+     * @param {string} apiVersion - Versión de la API
+     */
+    constructor(httpClient, apiVersion) {
+        super(httpClient, 'people', apiVersion);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGVyc29uLXNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc2VydmljZXMvcGVyc29uLXNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFHaEU7O0dBRUc7QUFDSCxNQUFNLE9BQU8sYUFBYyxTQUFRLG9CQUE0QjtJQUM3RDs7OztPQUlHO0lBQ0gsWUFBWSxVQUFnQyxFQUFFLFVBQWtCO1FBQzlELEtBQUssQ0FBQyxVQUFVLEVBQUUsUUFBUSxFQUFFLFVBQVUsQ0FBQyxDQUFDO0lBQzFDLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbIlxuaW1wb3J0IHsgUGVyc29uIH0gZnJvbSAnLi4vbW9kZWxzL3BlcnNvbic7XG5pbXBvcnQgeyBJRmlzY2FsYXBpSHR0cENsaWVudCB9IGZyb20gJy4uL2h0dHAvZmlzY2FsYXBpLWh0dHAtY2xpZW50LmludGVyZmFjZSc7XG5pbXBvcnQgeyBCYXNlRmlzY2FsYXBpU2VydmljZSB9IGZyb20gJy4vYmFzZS1maXNjYWxhcGktc2VydmljZSc7XG5pbXBvcnQgeyBJUGVyc29uU2VydmljZSB9IGZyb20gJy4uJztcblxuLyoqXG4gKiBJbXBsZW1lbnRhY2nDs24gZGVsIHNlcnZpY2lvIGRlIHBlcnNvbmFzXG4gKi9cbmV4cG9ydCBjbGFzcyBQZXJzb25TZXJ2aWNlIGV4dGVuZHMgQmFzZUZpc2NhbGFwaVNlcnZpY2U8UGVyc29uPiBpbXBsZW1lbnRzIElQZXJzb25TZXJ2aWNlIHtcbiAgLyoqXG4gICAqIENyZWEgdW5hIG51ZXZhIGluc3RhbmNpYSBkZWwgc2VydmljaW8gZGUgcGVyc29uYXNcbiAgICogQHBhcmFtIHtJRmlzY2FsYXBpSHR0cENsaWVudH0gaHR0cENsaWVudCAtIENsaWVudGUgSFRUUFxuICAgKiBAcGFyYW0ge3N0cmluZ30gYXBpVmVyc2lvbiAtIFZlcnNpw7NuIGRlIGxhIEFQSVxuICAgKi9cbiAgY29uc3RydWN0b3IoaHR0cENsaWVudDogSUZpc2NhbGFwaUh0dHBDbGllbnQsIGFwaVZlcnNpb246IHN0cmluZykge1xuICAgIHN1cGVyKGh0dHBDbGllbnQsICdwZW9wbGUnLCBhcGlWZXJzaW9uKTtcbiAgfVxufVxuIl19

package/dist/esm/services/product-service.js

@@ -0,0 +1,15 @@
+import { BaseFiscalapiService } from './base-fiscalapi-service';
+/**
+ * Implementación del servicio de productos
+ */
+export class ProductService extends BaseFiscalapiService {
+    /**
+     * Crea una nueva instancia del servicio de productos
+     * @param {IFiscalapiHttpClient} httpClient - Cliente HTTP
+     * @param {string} apiVersion - Versión de la API
+     */
+    constructor(httpClient, apiVersion) {
+        super(httpClient, 'products', apiVersion);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvZHVjdC1zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3NlcnZpY2VzL3Byb2R1Y3Qtc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUdoRTs7R0FFRztBQUNILE1BQU0sT0FBTyxjQUFlLFNBQVEsb0JBQTZCO0lBQy9EOzs7O09BSUc7SUFDSCxZQUFZLFVBQWdDLEVBQUUsVUFBa0I7UUFDOUQsS0FBSyxDQUFDLFVBQVUsRUFBRSxVQUFVLEVBQUUsVUFBVSxDQUFDLENBQUM7SUFDNUMsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUHJvZHVjdCB9IGZyb20gJy4uL21vZGVscy9wcm9kdWN0JztcbmltcG9ydCB7IElGaXNjYWxhcGlIdHRwQ2xpZW50IH0gZnJvbSAnLi4vaHR0cC9maXNjYWxhcGktaHR0cC1jbGllbnQuaW50ZXJmYWNlJztcbmltcG9ydCB7IEJhc2VGaXNjYWxhcGlTZXJ2aWNlIH0gZnJvbSAnLi9iYXNlLWZpc2NhbGFwaS1zZXJ2aWNlJztcbmltcG9ydCB7IElQcm9kdWN0U2VydmljZSB9IGZyb20gJy4uJztcblxuLyoqXG4gKiBJbXBsZW1lbnRhY2nDs24gZGVsIHNlcnZpY2lvIGRlIHByb2R1Y3Rvc1xuICovXG5leHBvcnQgY2xhc3MgUHJvZHVjdFNlcnZpY2UgZXh0ZW5kcyBCYXNlRmlzY2FsYXBpU2VydmljZTxQcm9kdWN0PiBpbXBsZW1lbnRzIElQcm9kdWN0U2VydmljZSB7XG4gIC8qKlxuICAgKiBDcmVhIHVuYSBudWV2YSBpbnN0YW5jaWEgZGVsIHNlcnZpY2lvIGRlIHByb2R1Y3Rvc1xuICAgKiBAcGFyYW0ge0lGaXNjYWxhcGlIdHRwQ2xpZW50fSBodHRwQ2xpZW50IC0gQ2xpZW50ZSBIVFRQXG4gICAqIEBwYXJhbSB7c3RyaW5nfSBhcGlWZXJzaW9uIC0gVmVyc2nDs24gZGUgbGEgQVBJXG4gICAqL1xuICBjb25zdHJ1Y3RvcihodHRwQ2xpZW50OiBJRmlzY2FsYXBpSHR0cENsaWVudCwgYXBpVmVyc2lvbjogc3RyaW5nKSB7XG4gICAgc3VwZXIoaHR0cENsaWVudCwgJ3Byb2R1Y3RzJywgYXBpVmVyc2lvbik7XG4gIH1cbn0iXX0=

package/dist/esm/services/tax-file-service.js

@@ -0,0 +1,39 @@
+import { BaseFiscalapiService } from './base-fiscalapi-service';
+/**
+ * Implementación del servicio de archivos fiscales
+ */
+export class TaxFileService extends BaseFiscalapiService {
+    /**
+     * Crea una nueva instancia del servicio de archivos fiscales
+     * @param {IFiscalapiHttpClient} httpClient - Cliente HTTP
+     * @param {string} apiVersion - Versión de la API
+     */
+    constructor(httpClient, apiVersion) {
+        super(httpClient, 'tax-files', apiVersion);
+    }
+    /**
+     * 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
+     */
+    async getDefaultReferences(personId) {
+        // GET /api/v4/tax-files/{personId}/default-references
+        const path = `${personId}/default-references`;
+        const endpoint = this.buildEndpoint(path);
+        return this.httpClient.getAsync(endpoint);
+    }
+    /**
+    * 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
+    */
+    async getDefaultValues(personId) {
+        // GET /api/v4/tax-files/{personId}/default-values
+        const path = `${personId}/default-values`;
+        const endpoint = this.buildEndpoint(path);
+        return this.httpClient.getAsync(endpoint);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/utils/date-utils.js

@@ -0,0 +1,31 @@
+import { DateTime } from 'luxon';
+/**
+ * Formato de fecha SAT (para facturas mexicanas)
+ */
+export const SAT_DATE_FORMAT = 'yyyy-MM-dd\'T\'HH:mm:ss';
+/**
+ * Formatea una fecha de acuerdo al formato de fecha SAT
+ * @param {Date|string|DateTime} date - Fecha a formatear
+ * @returns {string} Cadena de fecha formateada
+ */
+export function formatSatDate(date) {
+    if (typeof date === 'string') {
+        return DateTime.fromISO(date).toFormat(SAT_DATE_FORMAT);
+    }
+    else if (date instanceof Date) {
+        return DateTime.fromJSDate(date).toFormat(SAT_DATE_FORMAT);
+    }
+    else if (date instanceof DateTime) {
+        return date.toFormat(SAT_DATE_FORMAT);
+    }
+    throw new Error('Formato de fecha inválido');
+}
+/**
+ * Analiza una cadena de formato de fecha SAT en un objeto DateTime
+ * @param {string} dateStr - Cadena de fecha en formato SAT
+ * @returns {DateTime} Objeto DateTime
+ */
+export function parseSatDate(dateStr) {
+    return DateTime.fromFormat(dateStr, SAT_DATE_FORMAT);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/utils/encoding-utils.js

@@ -0,0 +1,17 @@
+/**
+ * Codifica una cadena a base64
+ * @param {string} text - Texto a codificar
+ * @returns {string} Cadena codificada en base64
+ */
+export function encodeToBase64(text) {
+    return Buffer.from(text).toString('base64');
+}
+/**
+ * Decodifica una cadena base64
+ * @param {string} base64Text - Cadena codificada en base64
+ * @returns {string} Cadena decodificada
+ */
+export function decodeFromBase64(base64Text) {
+    return Buffer.from(base64Text, 'base64').toString('utf8');
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW5jb2RpbmctdXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdXRpbHMvZW5jb2RpbmctdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0E7Ozs7R0FJRztBQUNILE1BQU0sVUFBVSxjQUFjLENBQUMsSUFBWTtJQUN2QyxPQUFPLE1BQU0sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxDQUFDO0FBQzlDLENBQUM7QUFFRDs7OztHQUlHO0FBQ0gsTUFBTSxVQUFVLGdCQUFnQixDQUFDLFVBQWtCO0lBQ2pELE9BQU8sTUFBTSxDQUFDLElBQUksQ0FBQyxVQUFVLEVBQUUsUUFBUSxDQUFDLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxDQUFDO0FBQzVELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIgXG4vKipcbiAqIENvZGlmaWNhIHVuYSBjYWRlbmEgYSBiYXNlNjRcbiAqIEBwYXJhbSB7c3RyaW5nfSB0ZXh0IC0gVGV4dG8gYSBjb2RpZmljYXJcbiAqIEByZXR1cm5zIHtzdHJpbmd9IENhZGVuYSBjb2RpZmljYWRhIGVuIGJhc2U2NFxuICovXG5leHBvcnQgZnVuY3Rpb24gZW5jb2RlVG9CYXNlNjQodGV4dDogc3RyaW5nKTogc3RyaW5nIHtcbiAgICByZXR1cm4gQnVmZmVyLmZyb20odGV4dCkudG9TdHJpbmcoJ2Jhc2U2NCcpO1xuICB9XG4gIFxuICAvKipcbiAgICogRGVjb2RpZmljYSB1bmEgY2FkZW5hIGJhc2U2NFxuICAgKiBAcGFyYW0ge3N0cmluZ30gYmFzZTY0VGV4dCAtIENhZGVuYSBjb2RpZmljYWRhIGVuIGJhc2U2NFxuICAgKiBAcmV0dXJucyB7c3RyaW5nfSBDYWRlbmEgZGVjb2RpZmljYWRhXG4gICAqL1xuICBleHBvcnQgZnVuY3Rpb24gZGVjb2RlRnJvbUJhc2U2NChiYXNlNjRUZXh0OiBzdHJpbmcpOiBzdHJpbmcge1xuICAgIHJldHVybiBCdWZmZXIuZnJvbShiYXNlNjRUZXh0LCAnYmFzZTY0JykudG9TdHJpbmcoJ3V0ZjgnKTtcbiAgfSJdfQ==

package/dist/esm/utils/validation-utils.js

@@ -0,0 +1,34 @@
+/**
+ * Comprueba si un valor es nulo o indefinido
+ * @param {any} value - Valor a comprobar
+ * @returns {boolean} Verdadero si el valor es nulo o indefinido, falso en caso contrario
+ */
+export function isNullOrUndefined(value) {
+    return value === null || value === undefined;
+}
+/**
+ * Comprueba si una cadena es nula, indefinida o vacía
+ * @param {string|null|undefined} value - Cadena a comprobar
+ * @returns {boolean} Verdadero si la cadena es nula, indefinida o vacía, falso en caso contrario
+ */
+export function isNullOrEmpty(value) {
+    return isNullOrUndefined(value) || value === '';
+}
+/**
+ * Comprueba si un array es nulo, indefinido o vacío
+ * @param {T[]|null|undefined} value - Array a comprobar
+ * @returns {boolean} Verdadero si el array es nulo, indefinido o vacío, falso en caso contrario
+ * @template T
+ */
+export function isArrayNullOrEmpty(value) {
+    return isNullOrUndefined(value) || (Array.isArray(value) && value.length === 0);
+}
+/**
+ * Comprueba si un objeto es nulo, indefinido o no tiene propiedades
+ * @param {object|null|undefined} value - Objeto a comprobar
+ * @returns {boolean} Verdadero si el objeto es nulo, indefinido o no tiene propiedades, falso en caso contrario
+ */
+export function isObjectEmpty(value) {
+    return isNullOrUndefined(value) || (typeof value === 'object' && value !== null && Object.keys(value).length === 0);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/types/abstractions/api-key-service.interface.d.ts

@@ -0,0 +1,7 @@
+import { IFiscalapiService } from './fiscalapi-service.interface';
+import { ApiKey } from '../models/api-key';
+/**
+ * Interfaz del servicio de claves de API
+ */
+export interface IApiKeyService extends IFiscalapiService<ApiKey> {
+}