fiscalapi 1.0.0

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

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseFiscalapiService = void 0;
+/**
+ * Implementación base de un servicio de FiscalAPI
+ * @template T - Tipo de DTO que maneja el servicio
+ */
+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
+        });
+    }
+}
+exports.BaseFiscalapiService = BaseFiscalapiService;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-fiscalapi-service.js","sourceRoot":"","sources":["../../../src/services/base-fiscalapi-service.ts"],"names":[],"mappings":"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","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/cjs/services/catalog-service.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CatalogService = void 0;
+const base_fiscalapi_service_1 = require("./base-fiscalapi-service");
+/**
+ * Implementación del servicio de catálogos
+ */
+class CatalogService extends base_fiscalapi_service_1.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;
+    }
+}
+exports.CatalogService = CatalogService;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FiscalapiClient = void 0;
+const fiscalapi_http_client_factory_1 = require("../http/fiscalapi-http-client-factory");
+const api_key_service_1 = require("./api-key-service");
+const catalog_service_1 = require("./catalog-service");
+const invoice_service_1 = require("./invoice-service");
+const person_service_1 = require("./person-service");
+const product_service_1 = require("./product-service");
+const tax_file_service_1 = require("./tax-file-service");
+/**
+ * Cliente principal para FiscalAPI
+ */
+class FiscalapiClient {
+    /**
+     * Crea una nueva instancia del cliente de FiscalAPI
+     * @param {FiscalapiSettings} settings - Configuración
+     * @private
+     */
+    constructor(settings) {
+        // Crea el cliente HTTP
+        const httpClient = fiscalapi_http_client_factory_1.FiscalapiHttpClientFactory.create(settings);
+        const apiVersion = settings.apiVersion || 'v4';
+        // Inicializa los servicios
+        this.invoices = new invoice_service_1.InvoiceService(httpClient, apiVersion);
+        this.products = new product_service_1.ProductService(httpClient, apiVersion);
+        this.persons = new person_service_1.PersonService(httpClient, apiVersion);
+        this.apiKeys = new api_key_service_1.ApiKeyService(httpClient, apiVersion);
+        this.catalogs = new catalog_service_1.CatalogService(httpClient, apiVersion);
+        this.taxFiles = new tax_file_service_1.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');
+        }
+    }
+}
+exports.FiscalapiClient = FiscalapiClient;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlzY2FsYXBpLWNsaWVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zZXJ2aWNlcy9maXNjYWxhcGktY2xpZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQVNBLHlGQUFtRjtBQUNuRix1REFBa0Q7QUFDbEQsdURBQW1EO0FBQ25ELHVEQUFtRDtBQUNuRCxxREFBaUQ7QUFDakQsdURBQW1EO0FBQ25ELHlEQUFvRDtBQUVwRDs7R0FFRztBQUNILE1BQWEsZUFBZTtJQStCMUI7Ozs7T0FJRztJQUNILFlBQW9CLFFBQTJCO1FBQzdDLHVCQUF1QjtRQUN2QixNQUFNLFVBQVUsR0FBRywwREFBMEIsQ0FBQyxNQUFNLENBQUMsUUFBUSxDQUFDLENBQUM7UUFDL0QsTUFBTSxVQUFVLEdBQUcsUUFBUSxDQUFDLFVBQVUsSUFBSSxJQUFJLENBQUM7UUFFL0MsMkJBQTJCO1FBQzNCLElBQUksQ0FBQyxRQUFRLEdBQUcsSUFBSSxnQ0FBYyxDQUFDLFVBQVUsRUFBRSxVQUFVLENBQUMsQ0FBQztRQUMzRCxJQUFJLENBQUMsUUFBUSxHQUFHLElBQUksZ0NBQWMsQ0FBQyxVQUFVLEVBQUUsVUFBVSxDQUFDLENBQUM7UUFDM0QsSUFBSSxDQUFDLE9BQU8sR0FBRyxJQUFJLDhCQUFhLENBQUMsVUFBVSxFQUFFLFVBQVUsQ0FBQyxDQUFDO1FBQ3pELElBQUksQ0FBQyxPQUFPLEdBQUcsSUFBSSwrQkFBYSxDQUFDLFVBQVUsRUFBRSxVQUFVLENBQUMsQ0FBQztRQUN6RCxJQUFJLENBQUMsUUFBUSxHQUFHLElBQUksZ0NBQWMsQ0FBQyxVQUFVLEVBQUUsVUFBVSxDQUFDLENBQUM7UUFDM0QsSUFBSSxDQUFDLFFBQVEsR0FBRyxJQUFJLGlDQUFjLENBQUMsVUFBVSxFQUFFLFVBQVUsQ0FBQyxDQUFDO0lBQzdELENBQUM7SUFFRDs7OztPQUlHO0lBQ0gsTUFBTSxDQUFDLE1BQU0sQ0FBQyxRQUEyQjtRQUN2QyxJQUFJLENBQUMsUUFBUSxFQUFFLENBQUM7WUFDZCxNQUFNLElBQUksS0FBSyxDQUFDLGlEQUFpRCxDQUFDLENBQUM7UUFDckUsQ0FBQztRQUVELDBCQUEwQjtRQUMxQixlQUFlLENBQUMsZ0JBQWdCLENBQUMsUUFBUSxDQUFDLENBQUM7UUFFM0Msb0VBQW9FO1FBQ3BFLFFBQVEsQ0FBQyxVQUFVLEdBQUcsUUFBUSxDQUFDLFVBQVUsSUFBSSxJQUFJLENBQUM7UUFDbEQsUUFBUSxDQUFDLFFBQVEsR0FBRyxRQUFRLENBQUMsUUFBUSxJQUFJLHFCQUFxQixDQUFDO1FBQy9ELFFBQVEsQ0FBQyxLQUFLLEdBQUcsUUFBUSxDQUFDLEtBQUssSUFBSSxLQUFLLENBQUM7UUFFekMsT0FBTyxJQUFJLGVBQWUsQ0FBQyxRQUFRLENBQUMsQ0FBQztJQUN2QyxDQUFDO0lBRUQ7Ozs7T0FJRztJQUNLLE1BQU0sQ0FBQyxnQkFBZ0IsQ0FBQyxRQUEyQjtRQUN6RCxJQUFJLENBQUMsUUFBUSxDQUFDLE1BQU0sRUFBRSxDQUFDO1lBQ3JCLE1BQU0sSUFBSSxLQUFLLENBQUMscUJBQXFCLENBQUMsQ0FBQztRQUN6QyxDQUFDO1FBRUQsSUFBSSxDQUFDLFFBQVEsQ0FBQyxNQUFNLEVBQUUsQ0FBQztZQUNyQixNQUFNLElBQUksS0FBSyxDQUFDLHFCQUFxQixDQUFDLENBQUM7UUFDekMsQ0FBQztRQUVELElBQUksQ0FBQyxRQUFRLENBQUMsTUFBTSxFQUFFLENBQUM7WUFDckIsTUFBTSxJQUFJLEtBQUssQ0FBQyxxQkFBcUIsQ0FBQyxDQUFDO1FBQ3pDLENBQUM7SUFDSCxDQUFDO0NBQ0Y7QUF6RkQsMENBeUZDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgXG4gIElGaXNjYWxhcGlDbGllbnQsXG4gIElJbnZvaWNlU2VydmljZSwgXG4gIElQcm9kdWN0U2VydmljZSwgXG4gIElQZXJzb25TZXJ2aWNlLCBcbiAgSUFwaUtleVNlcnZpY2UsIFxuICBJQ2F0YWxvZ1NlcnZpY2UsIFxuICBJVGF4RmlsZVNlcnZpY2UgfSBmcm9tICcuLic7XG5pbXBvcnQgeyBGaXNjYWxhcGlTZXR0aW5ncyB9IGZyb20gJy4uL2NvbW1vbi9maXNjYWxhcGktc2V0dGluZ3MnO1xuaW1wb3J0IHsgRmlzY2FsYXBpSHR0cENsaWVudEZhY3RvcnkgfSBmcm9tICcuLi9odHRwL2Zpc2NhbGFwaS1odHRwLWNsaWVudC1mYWN0b3J5JztcbmltcG9ydCB7IEFwaUtleVNlcnZpY2UgfSBmcm9tICcuL2FwaS1rZXktc2VydmljZSc7XG5pbXBvcnQgeyBDYXRhbG9nU2VydmljZSB9IGZyb20gJy4vY2F0YWxvZy1zZXJ2aWNlJztcbmltcG9ydCB7IEludm9pY2VTZXJ2aWNlIH0gZnJvbSAnLi9pbnZvaWNlLXNlcnZpY2UnO1xuaW1wb3J0IHsgUGVyc29uU2VydmljZSB9IGZyb20gJy4vcGVyc29uLXNlcnZpY2UnO1xuaW1wb3J0IHsgUHJvZHVjdFNlcnZpY2UgfSBmcm9tICcuL3Byb2R1Y3Qtc2VydmljZSc7XG5pbXBvcnQgeyBUYXhGaWxlU2VydmljZSB9IGZyb20gJy4vdGF4LWZpbGUtc2VydmljZSc7XG5cbi8qKlxuICogQ2xpZW50ZSBwcmluY2lwYWwgcGFyYSBGaXNjYWxBUElcbiAqL1xuZXhwb3J0IGNsYXNzIEZpc2NhbGFwaUNsaWVudCBpbXBsZW1lbnRzIElGaXNjYWxhcGlDbGllbnQge1xuICAvKipcbiAgICogU2VydmljaW8gZGUgZmFjdHVyYXNcbiAgICovXG4gIHJlYWRvbmx5IGludm9pY2VzOiBJSW52b2ljZVNlcnZpY2U7XG4gIFxuICAvKipcbiAgICogU2VydmljaW8gZGUgcHJvZHVjdG9zXG4gICAqL1xuICByZWFkb25seSBwcm9kdWN0czogSVByb2R1Y3RTZXJ2aWNlO1xuICBcbiAgLyoqXG4gICAqIFNlcnZpY2lvIGRlIHBlcnNvbmFzXG4gICAqL1xuICByZWFkb25seSBwZXJzb25zOiBJUGVyc29uU2VydmljZTtcbiAgXG4gIC8qKlxuICAgKiBTZXJ2aWNpbyBkZSBjbGF2ZXMgZGUgQVBJXG4gICAqL1xuICByZWFkb25seSBhcGlLZXlzOiBJQXBpS2V5U2VydmljZTtcbiAgXG4gIC8qKlxuICAgKiBTZXJ2aWNpbyBkZSBjYXTDoWxvZ29zXG4gICAqL1xuICByZWFkb25seSBjYXRhbG9nczogSUNhdGFsb2dTZXJ2aWNlO1xuICBcbiAgLyoqXG4gICAqIFNlcnZpY2lvIGRlIGFyY2hpdm9zIGZpc2NhbGVzXG4gICAqL1xuICByZWFkb25seSB0YXhGaWxlczogSVRheEZpbGVTZXJ2aWNlO1xuXG4gIC8qKlxuICAgKiBDcmVhIHVuYSBudWV2YSBpbnN0YW5jaWEgZGVsIGNsaWVudGUgZGUgRmlzY2FsQVBJXG4gICAqIEBwYXJhbSB7RmlzY2FsYXBpU2V0dGluZ3N9IHNldHRpbmdzIC0gQ29uZmlndXJhY2nDs25cbiAgICogQHByaXZhdGVcbiAgICovXG4gIHByaXZhdGUgY29uc3RydWN0b3Ioc2V0dGluZ3M6IEZpc2NhbGFwaVNldHRpbmdzKSB7XG4gICAgLy8gQ3JlYSBlbCBjbGllbnRlIEhUVFBcbiAgICBjb25zdCBodHRwQ2xpZW50ID0gRmlzY2FsYXBpSHR0cENsaWVudEZhY3RvcnkuY3JlYXRlKHNldHRpbmdzKTtcbiAgICBjb25zdCBhcGlWZXJzaW9uID0gc2V0dGluZ3MuYXBpVmVyc2lvbiB8fCAndjQnO1xuICAgIFxuICAgIC8vIEluaWNpYWxpemEgbG9zIHNlcnZpY2lvc1xuICAgIHRoaXMuaW52b2ljZXMgPSBuZXcgSW52b2ljZVNlcnZpY2UoaHR0cENsaWVudCwgYXBpVmVyc2lvbik7XG4gICAgdGhpcy5wcm9kdWN0cyA9IG5ldyBQcm9kdWN0U2VydmljZShodHRwQ2xpZW50LCBhcGlWZXJzaW9uKTtcbiAgICB0aGlzLnBlcnNvbnMgPSBuZXcgUGVyc29uU2VydmljZShodHRwQ2xpZW50LCBhcGlWZXJzaW9uKTtcbiAgICB0aGlzLmFwaUtleXMgPSBuZXcgQXBpS2V5U2VydmljZShodHRwQ2xpZW50LCBhcGlWZXJzaW9uKTtcbiAgICB0aGlzLmNhdGFsb2dzID0gbmV3IENhdGFsb2dTZXJ2aWNlKGh0dHBDbGllbnQsIGFwaVZlcnNpb24pO1xuICAgIHRoaXMudGF4RmlsZXMgPSBuZXcgVGF4RmlsZVNlcnZpY2UoaHR0cENsaWVudCwgYXBpVmVyc2lvbik7XG4gIH1cblxuICAvKipcbiAgICogQ3JlYSB1bmEgbnVldmEgaW5zdGFuY2lhIGRlbCBjbGllbnRlIGRlIEZpc2NhbEFQSVxuICAgKiBAcGFyYW0ge0Zpc2NhbGFwaVNldHRpbmdzfSBzZXR0aW5ncyAtIENvbmZpZ3VyYWNpw7NuXG4gICAqIEByZXR1cm5zIHtJRmlzY2FsYXBpQ2xpZW50fSBJbnN0YW5jaWEgZGVsIGNsaWVudGUgZGUgRmlzY2FsQVBJXG4gICAqL1xuICBzdGF0aWMgY3JlYXRlKHNldHRpbmdzOiBGaXNjYWxhcGlTZXR0aW5ncyk6IElGaXNjYWxhcGlDbGllbnQge1xuICAgIGlmICghc2V0dGluZ3MpIHtcbiAgICAgIHRocm93IG5ldyBFcnJvcignTGEgY29uZmlndXJhY2nDs24gbm8gcHVlZGUgc2VyIG51bGEgbyBpbmRlZmluaWRhJyk7XG4gICAgfVxuICAgIFxuICAgIC8vIFZhbGlkYSBsYSBjb25maWd1cmFjacOzblxuICAgIEZpc2NhbGFwaUNsaWVudC52YWxpZGF0ZVNldHRpbmdzKHNldHRpbmdzKTtcbiAgICBcbiAgICAvLyBFc3RhYmxlY2UgdmFsb3JlcyBwcmVkZXRlcm1pbmFkb3MgcGFyYSBjb25maWd1cmFjaW9uZXMgb3BjaW9uYWxlc1xuICAgIHNldHRpbmdzLmFwaVZlcnNpb24gPSBzZXR0aW5ncy5hcGlWZXJzaW9uIHx8ICd2NCc7XG4gICAgc2V0dGluZ3MudGltZVpvbmUgPSBzZXR0aW5ncy50aW1lWm9uZSB8fCAnQW1lcmljYS9NZXhpY29fQ2l0eSc7XG4gICAgc2V0dGluZ3MuZGVidWcgPSBzZXR0aW5ncy5kZWJ1ZyB8fCBmYWxzZTtcbiAgICBcbiAgICByZXR1cm4gbmV3IEZpc2NhbGFwaUNsaWVudChzZXR0aW5ncyk7XG4gIH1cblxuICAvKipcbiAgICogVmFsaWRhIGxhIGNvbmZpZ3VyYWNpw7NuXG4gICAqIEBwYXJhbSB7RmlzY2FsYXBpU2V0dGluZ3N9IHNldHRpbmdzIC0gQ29uZmlndXJhY2nDs25cbiAgICogQHByaXZhdGVcbiAgICovXG4gIHByaXZhdGUgc3RhdGljIHZhbGlkYXRlU2V0dGluZ3Moc2V0dGluZ3M6IEZpc2NhbGFwaVNldHRpbmdzKTogdm9pZCB7XG4gICAgaWYgKCFzZXR0aW5ncy5hcGlVcmwpIHtcbiAgICAgIHRocm93IG5ldyBFcnJvcignYXBpVXJsIGVzIHJlcXVlcmlkbycpO1xuICAgIH1cbiAgICBcbiAgICBpZiAoIXNldHRpbmdzLmFwaUtleSkge1xuICAgICAgdGhyb3cgbmV3IEVycm9yKCdhcGlLZXkgZXMgcmVxdWVyaWRvJyk7XG4gICAgfVxuICAgIFxuICAgIGlmICghc2V0dGluZ3MudGVuYW50KSB7XG4gICAgICB0aHJvdyBuZXcgRXJyb3IoJ3RlbmFudCBlcyByZXF1ZXJpZG8nKTtcbiAgICB9XG4gIH1cbn1cbiJdfQ==

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

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvoiceService = void 0;
+const base_fiscalapi_service_1 = require("./base-fiscalapi-service");
+/**
+ * Implementación del servicio de facturas
+ */
+class InvoiceService extends base_fiscalapi_service_1.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',
+        });
+    }
+}
+exports.InvoiceService = InvoiceService;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"invoice-service.js","sourceRoot":"","sources":["../../../src/services/invoice-service.ts"],"names":[],"mappings":";;;AAGA,qEAAgE;AAYhE;;GAEG;AACH,MAAa,cAAe,SAAQ,6CAA6B;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;AAxHD,wCAwHC","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/cjs/services/person-service.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PersonService = void 0;
+const base_fiscalapi_service_1 = require("./base-fiscalapi-service");
+/**
+ * Implementación del servicio de personas
+ */
+class PersonService extends base_fiscalapi_service_1.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);
+    }
+}
+exports.PersonService = PersonService;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGVyc29uLXNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc2VydmljZXMvcGVyc29uLXNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBR0EscUVBQWdFO0FBR2hFOztHQUVHO0FBQ0gsTUFBYSxhQUFjLFNBQVEsNkNBQTRCO0lBQzdEOzs7O09BSUc7SUFDSCxZQUFZLFVBQWdDLEVBQUUsVUFBa0I7UUFDOUQsS0FBSyxDQUFDLFVBQVUsRUFBRSxRQUFRLEVBQUUsVUFBVSxDQUFDLENBQUM7SUFDMUMsQ0FBQztDQUNGO0FBVEQsc0NBU0MiLCJzb3VyY2VzQ29udGVudCI6WyJcbmltcG9ydCB7IFBlcnNvbiB9IGZyb20gJy4uL21vZGVscy9wZXJzb24nO1xuaW1wb3J0IHsgSUZpc2NhbGFwaUh0dHBDbGllbnQgfSBmcm9tICcuLi9odHRwL2Zpc2NhbGFwaS1odHRwLWNsaWVudC5pbnRlcmZhY2UnO1xuaW1wb3J0IHsgQmFzZUZpc2NhbGFwaVNlcnZpY2UgfSBmcm9tICcuL2Jhc2UtZmlzY2FsYXBpLXNlcnZpY2UnO1xuaW1wb3J0IHsgSVBlcnNvblNlcnZpY2UgfSBmcm9tICcuLic7XG5cbi8qKlxuICogSW1wbGVtZW50YWNpw7NuIGRlbCBzZXJ2aWNpbyBkZSBwZXJzb25hc1xuICovXG5leHBvcnQgY2xhc3MgUGVyc29uU2VydmljZSBleHRlbmRzIEJhc2VGaXNjYWxhcGlTZXJ2aWNlPFBlcnNvbj4gaW1wbGVtZW50cyBJUGVyc29uU2VydmljZSB7XG4gIC8qKlxuICAgKiBDcmVhIHVuYSBudWV2YSBpbnN0YW5jaWEgZGVsIHNlcnZpY2lvIGRlIHBlcnNvbmFzXG4gICAqIEBwYXJhbSB7SUZpc2NhbGFwaUh0dHBDbGllbnR9IGh0dHBDbGllbnQgLSBDbGllbnRlIEhUVFBcbiAgICogQHBhcmFtIHtzdHJpbmd9IGFwaVZlcnNpb24gLSBWZXJzacOzbiBkZSBsYSBBUElcbiAgICovXG4gIGNvbnN0cnVjdG9yKGh0dHBDbGllbnQ6IElGaXNjYWxhcGlIdHRwQ2xpZW50LCBhcGlWZXJzaW9uOiBzdHJpbmcpIHtcbiAgICBzdXBlcihodHRwQ2xpZW50LCAncGVvcGxlJywgYXBpVmVyc2lvbik7XG4gIH1cbn1cbiJdfQ==

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductService = void 0;
+const base_fiscalapi_service_1 = require("./base-fiscalapi-service");
+/**
+ * Implementación del servicio de productos
+ */
+class ProductService extends base_fiscalapi_service_1.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);
+    }
+}
+exports.ProductService = ProductService;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvZHVjdC1zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3NlcnZpY2VzL3Byb2R1Y3Qtc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFFQSxxRUFBZ0U7QUFHaEU7O0dBRUc7QUFDSCxNQUFhLGNBQWUsU0FBUSw2Q0FBNkI7SUFDL0Q7Ozs7T0FJRztJQUNILFlBQVksVUFBZ0MsRUFBRSxVQUFrQjtRQUM5RCxLQUFLLENBQUMsVUFBVSxFQUFFLFVBQVUsRUFBRSxVQUFVLENBQUMsQ0FBQztJQUM1QyxDQUFDO0NBQ0Y7QUFURCx3Q0FTQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFByb2R1Y3QgfSBmcm9tICcuLi9tb2RlbHMvcHJvZHVjdCc7XG5pbXBvcnQgeyBJRmlzY2FsYXBpSHR0cENsaWVudCB9IGZyb20gJy4uL2h0dHAvZmlzY2FsYXBpLWh0dHAtY2xpZW50LmludGVyZmFjZSc7XG5pbXBvcnQgeyBCYXNlRmlzY2FsYXBpU2VydmljZSB9IGZyb20gJy4vYmFzZS1maXNjYWxhcGktc2VydmljZSc7XG5pbXBvcnQgeyBJUHJvZHVjdFNlcnZpY2UgfSBmcm9tICcuLic7XG5cbi8qKlxuICogSW1wbGVtZW50YWNpw7NuIGRlbCBzZXJ2aWNpbyBkZSBwcm9kdWN0b3NcbiAqL1xuZXhwb3J0IGNsYXNzIFByb2R1Y3RTZXJ2aWNlIGV4dGVuZHMgQmFzZUZpc2NhbGFwaVNlcnZpY2U8UHJvZHVjdD4gaW1wbGVtZW50cyBJUHJvZHVjdFNlcnZpY2Uge1xuICAvKipcbiAgICogQ3JlYSB1bmEgbnVldmEgaW5zdGFuY2lhIGRlbCBzZXJ2aWNpbyBkZSBwcm9kdWN0b3NcbiAgICogQHBhcmFtIHtJRmlzY2FsYXBpSHR0cENsaWVudH0gaHR0cENsaWVudCAtIENsaWVudGUgSFRUUFxuICAgKiBAcGFyYW0ge3N0cmluZ30gYXBpVmVyc2lvbiAtIFZlcnNpw7NuIGRlIGxhIEFQSVxuICAgKi9cbiAgY29uc3RydWN0b3IoaHR0cENsaWVudDogSUZpc2NhbGFwaUh0dHBDbGllbnQsIGFwaVZlcnNpb246IHN0cmluZykge1xuICAgIHN1cGVyKGh0dHBDbGllbnQsICdwcm9kdWN0cycsIGFwaVZlcnNpb24pO1xuICB9XG59Il19

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaxFileService = void 0;
+const base_fiscalapi_service_1 = require("./base-fiscalapi-service");
+/**
+ * Implementación del servicio de archivos fiscales
+ */
+class TaxFileService extends base_fiscalapi_service_1.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);
+    }
+}
+exports.TaxFileService = TaxFileService;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGF4LWZpbGUtc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zZXJ2aWNlcy90YXgtZmlsZS1zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUlBLHFFQUFnRTtBQUdoRTs7R0FFRztBQUNILE1BQWEsY0FBZSxTQUFRLDZDQUE2QjtJQUMvRDs7OztPQUlHO0lBQ0gsWUFBWSxVQUFnQyxFQUFFLFVBQWtCO1FBQzlELEtBQUssQ0FBQyxVQUFVLEVBQUUsV0FBVyxFQUFFLFVBQVUsQ0FBQyxDQUFDO0lBQzdDLENBQUM7SUFHQzs7Ozs7T0FLRztJQUNILEtBQUssQ0FBQyxvQkFBb0IsQ0FBQyxRQUFnQjtRQUN6QyxzREFBc0Q7UUFDdEQsTUFBTSxJQUFJLEdBQUcsR0FBRyxRQUFRLHFCQUFxQixDQUFDO1FBQzlDLE1BQU0sUUFBUSxHQUFHLElBQUksQ0FBQyxhQUFhLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDMUMsT0FBTyxJQUFJLENBQUMsVUFBVSxDQUFDLFFBQVEsQ0FBWSxRQUFRLENBQUMsQ0FBQztJQUN2RCxDQUFDO0lBRUQ7Ozs7O01BS0U7SUFDSyxLQUFLLENBQUMsZ0JBQWdCLENBQUMsUUFBZ0I7UUFDNUMsa0RBQWtEO1FBQ2xELE1BQU0sSUFBSSxHQUFHLEdBQUcsUUFBUSxpQkFBaUIsQ0FBQztRQUMxQyxNQUFNLFFBQVEsR0FBRyxJQUFJLENBQUMsYUFBYSxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQzFDLE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQyxRQUFRLENBQVksUUFBUSxDQUFDLENBQUM7SUFDdkQsQ0FBQztDQUNKO0FBcENELHdDQW9DQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFRheEZpbGUgfSBmcm9tICcuLi9tb2RlbHMvdGF4LWZpbGUnO1xuaW1wb3J0IHsgSUZpc2NhbGFwaUh0dHBDbGllbnQgfSBmcm9tICcuLi9odHRwL2Zpc2NhbGFwaS1odHRwLWNsaWVudC5pbnRlcmZhY2UnO1xuaW1wb3J0IHsgQXBpUmVzcG9uc2UgfSBmcm9tICcuLi9jb21tb24vYXBpLXJlc3BvbnNlJztcbmltcG9ydCB7IEZpbGVSZXNwb25zZSB9IGZyb20gJy4uL2NvbW1vbi9maWxlLXJlc3BvbnNlJztcbmltcG9ydCB7IEJhc2VGaXNjYWxhcGlTZXJ2aWNlIH0gZnJvbSAnLi9iYXNlLWZpc2NhbGFwaS1zZXJ2aWNlJztcbmltcG9ydCB7IElUYXhGaWxlU2VydmljZSB9IGZyb20gJy4uJztcblxuLyoqXG4gKiBJbXBsZW1lbnRhY2nDs24gZGVsIHNlcnZpY2lvIGRlIGFyY2hpdm9zIGZpc2NhbGVzXG4gKi9cbmV4cG9ydCBjbGFzcyBUYXhGaWxlU2VydmljZSBleHRlbmRzIEJhc2VGaXNjYWxhcGlTZXJ2aWNlPFRheEZpbGU+IGltcGxlbWVudHMgSVRheEZpbGVTZXJ2aWNlIHtcbiAgLyoqXG4gICAqIENyZWEgdW5hIG51ZXZhIGluc3RhbmNpYSBkZWwgc2VydmljaW8gZGUgYXJjaGl2b3MgZmlzY2FsZXNcbiAgICogQHBhcmFtIHtJRmlzY2FsYXBpSHR0cENsaWVudH0gaHR0cENsaWVudCAtIENsaWVudGUgSFRUUFxuICAgKiBAcGFyYW0ge3N0cmluZ30gYXBpVmVyc2lvbiAtIFZlcnNpw7NuIGRlIGxhIEFQSVxuICAgKi9cbiAgY29uc3RydWN0b3IoaHR0cENsaWVudDogSUZpc2NhbGFwaUh0dHBDbGllbnQsIGFwaVZlcnNpb246IHN0cmluZykge1xuICAgIHN1cGVyKGh0dHBDbGllbnQsICd0YXgtZmlsZXMnLCBhcGlWZXJzaW9uKTtcbiAgfVxuXG5cbiAgICAvKipcbiAgICAgKiBPYnRpZW5lIGVsIMO6bHRpbW8gcGFyIGRlIGlkcyBkZSBjZXJ0aWZpY2Fkb3MgdsOhbGlkb3MgeSB2aWdlbnRlIGRlIHVuYSBwZXJzb25hLiBFcyBkZWNpciBzdXMgY2VydGlmaWNhZG9zIHBvciBkZWZlY3RvIChpZHMpXG4gICAgICogXG4gICAgICogQHBhcmFtIHBlcnNvbklkIC0gSWQgZGUgbGEgcGVyc29uYSBwcm9waWV0YXJpYSBkZSBsb3MgY2VydGlmaWNhZG9zXG4gICAgICogQHJldHVybnMgUHJvbWlzZSBxdWUgcmVzdWVsdmUgZW4gdW5hIHJlc3B1ZXN0YSBBUEkgY29uIHVuYSBsaXN0YSBkZSB1biBwYXIgZGUgY2VydGlmaWNhZG9zLCBwZXJvIHNpbiBjb250ZW5pZG8sIHNvbG8gc3VzIElkc1xuICAgICAqL1xuICAgIGFzeW5jIGdldERlZmF1bHRSZWZlcmVuY2VzKHBlcnNvbklkOiBzdHJpbmcpOiBQcm9taXNlPEFwaVJlc3BvbnNlPFRheEZpbGVbXT4+IHtcbiAgICAgIC8vIEdFVCAvYXBpL3Y0L3RheC1maWxlcy97cGVyc29uSWR9L2RlZmF1bHQtcmVmZXJlbmNlc1xuICAgICAgY29uc3QgcGF0aCA9IGAke3BlcnNvbklkfS9kZWZhdWx0LXJlZmVyZW5jZXNgO1xuICAgICAgY29uc3QgZW5kcG9pbnQgPSB0aGlzLmJ1aWxkRW5kcG9pbnQocGF0aCk7XG4gICAgICByZXR1cm4gdGhpcy5odHRwQ2xpZW50LmdldEFzeW5jPFRheEZpbGVbXT4oZW5kcG9pbnQpO1xuICAgIH1cblxuICAgIC8qKlxuICAgICogT2J0aWVuZSBlbCDDumx0aW1vIHBhciBkZSBjZXJ0aWZpY2Fkb3MgdsOhbGlkb3MgeSB2aWdlbnRlIGRlIHVuYSBwZXJzb25hLiBFcyBkZWNpciBzdXMgY2VydGlmaWNhZG9zIHBvciBkZWZlY3RvXG4gICAgKiBcbiAgICAqIEBwYXJhbSBwZXJzb25JZCAtIElkIGRlIGxhIHBlcnNvbmEgZHVlw7FhIGRlIGxvcyBjZXJ0aWZpY2Fkb3NcbiAgICAqIEByZXR1cm5zIFByb21pc2UgcXVlIHJlc3VlbHZlIGVuIHVuYSByZXNwdWVzdGEgQVBJIGNvbiB1bmEgbGlzdGEgZGUgdW4gcGFyIGRlIGNlcnRpZmljYWRvc1xuICAgICovXG4gICAgcHVibGljIGFzeW5jIGdldERlZmF1bHRWYWx1ZXMocGVyc29uSWQ6IHN0cmluZyk6IFByb21pc2U8QXBpUmVzcG9uc2U8VGF4RmlsZVtdPj4ge1xuICAgICAgLy8gR0VUIC9hcGkvdjQvdGF4LWZpbGVzL3twZXJzb25JZH0vZGVmYXVsdC12YWx1ZXNcbiAgICAgIGNvbnN0IHBhdGggPSBgJHtwZXJzb25JZH0vZGVmYXVsdC12YWx1ZXNgO1xuICAgICAgY29uc3QgZW5kcG9pbnQgPSB0aGlzLmJ1aWxkRW5kcG9pbnQocGF0aCk7XG4gICAgICByZXR1cm4gdGhpcy5odHRwQ2xpZW50LmdldEFzeW5jPFRheEZpbGVbXT4oZW5kcG9pbnQpO1xuICAgIH1cbn0iXX0=

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SAT_DATE_FORMAT = void 0;
+exports.formatSatDate = formatSatDate;
+exports.parseSatDate = parseSatDate;
+const luxon_1 = require("luxon");
+/**
+ * Formato de fecha SAT (para facturas mexicanas)
+ */
+exports.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
+ */
+function formatSatDate(date) {
+    if (typeof date === 'string') {
+        return luxon_1.DateTime.fromISO(date).toFormat(exports.SAT_DATE_FORMAT);
+    }
+    else if (date instanceof Date) {
+        return luxon_1.DateTime.fromJSDate(date).toFormat(exports.SAT_DATE_FORMAT);
+    }
+    else if (date instanceof luxon_1.DateTime) {
+        return date.toFormat(exports.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
+ */
+function parseSatDate(dateStr) {
+    return luxon_1.DateTime.fromFormat(dateStr, exports.SAT_DATE_FORMAT);
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeToBase64 = encodeToBase64;
+exports.decodeFromBase64 = decodeFromBase64;
+/**
+ * Codifica una cadena a base64
+ * @param {string} text - Texto a codificar
+ * @returns {string} Cadena codificada en base64
+ */
+function encodeToBase64(text) {
+    return Buffer.from(text).toString('base64');
+}
+/**
+ * Decodifica una cadena base64
+ * @param {string} base64Text - Cadena codificada en base64
+ * @returns {string} Cadena decodificada
+ */
+function decodeFromBase64(base64Text) {
+    return Buffer.from(base64Text, 'base64').toString('utf8');
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW5jb2RpbmctdXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdXRpbHMvZW5jb2RpbmctdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFNQSx3Q0FFRztBQU9ELDRDQUVDO0FBaEJIOzs7O0dBSUc7QUFDSCxTQUFnQixjQUFjLENBQUMsSUFBWTtJQUN2QyxPQUFPLE1BQU0sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxDQUFDO0FBQzlDLENBQUM7QUFFRDs7OztHQUlHO0FBQ0gsU0FBZ0IsZ0JBQWdCLENBQUMsVUFBa0I7SUFDakQsT0FBTyxNQUFNLENBQUMsSUFBSSxDQUFDLFVBQVUsRUFBRSxRQUFRLENBQUMsQ0FBQyxRQUFRLENBQUMsTUFBTSxDQUFDLENBQUM7QUFDNUQsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIiBcbi8qKlxuICogQ29kaWZpY2EgdW5hIGNhZGVuYSBhIGJhc2U2NFxuICogQHBhcmFtIHtzdHJpbmd9IHRleHQgLSBUZXh0byBhIGNvZGlmaWNhclxuICogQHJldHVybnMge3N0cmluZ30gQ2FkZW5hIGNvZGlmaWNhZGEgZW4gYmFzZTY0XG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBlbmNvZGVUb0Jhc2U2NCh0ZXh0OiBzdHJpbmcpOiBzdHJpbmcge1xuICAgIHJldHVybiBCdWZmZXIuZnJvbSh0ZXh0KS50b1N0cmluZygnYmFzZTY0Jyk7XG4gIH1cbiAgXG4gIC8qKlxuICAgKiBEZWNvZGlmaWNhIHVuYSBjYWRlbmEgYmFzZTY0XG4gICAqIEBwYXJhbSB7c3RyaW5nfSBiYXNlNjRUZXh0IC0gQ2FkZW5hIGNvZGlmaWNhZGEgZW4gYmFzZTY0XG4gICAqIEByZXR1cm5zIHtzdHJpbmd9IENhZGVuYSBkZWNvZGlmaWNhZGFcbiAgICovXG4gIGV4cG9ydCBmdW5jdGlvbiBkZWNvZGVGcm9tQmFzZTY0KGJhc2U2NFRleHQ6IHN0cmluZyk6IHN0cmluZyB7XG4gICAgcmV0dXJuIEJ1ZmZlci5mcm9tKGJhc2U2NFRleHQsICdiYXNlNjQnKS50b1N0cmluZygndXRmOCcpO1xuICB9Il19