fiscalapi 4.0.141 → 4.0.270

package/dist/esm/models/download.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"download.js","sourceRoot":"","sources":["../../../src/models/download.ts"],"names":[],"mappings":"","sourcesContent":["import { DateTime } from 'luxon';\nimport { BaseDto } from '../common/base-dto';\nimport { CatalogDto } from '../common/catalog-dto';\nimport { Person } from './person';\n\n/**\n * Representa una plantilla para crear solicitudes de descarga de CFDI o metadatos.\n */\nexport interface DownloadRule extends BaseDto {\n  /** ID de la persona asociada a la regla de descarga */\n  personId?: string;\n  \n  /** Información de la persona asociada */\n  person?: Person;\n  \n  /** RFC (Tax Identification Number) del solicitante */\n  tin?: string;\n  \n  /** Descripción de la regla de descarga */\n  description?: string;\n\n  /** \n   * Estado de la regla de descarga\n   * 1: Pendiente, 2: Aprobada, 3: Rechazada, 4: Abandonada\n   */\n  downloadRuleStatusId?: string;\n  \n  /** Catálogo del estado de la regla de descarga */\n  downloadRuleStatus?: CatalogDto;\n\n  /**\n   * Tipo de consulta SAT\n   * CFDI, Metadata\n   */\n  satQueryTypeId?: string;\n  \n  /** Catálogo del tipo de consulta SAT */\n  satQueryType?: CatalogDto;\n\n  /**\n   * Tipo de descarga\n   * Emitidos, Recibidos\n   */\n  downloadTypeId?: string;\n  \n  /** Catálogo del tipo de descarga */\n  downloadType?: CatalogDto;\n\n  /**\n   * Estado de la factura SAT\n   * Vigente, Cancelado\n   */\n  satInvoiceStatusId?: string;\n  \n  /** Catálogo del estado de la factura SAT */\n  satInvoiceStatus?: CatalogDto;\n}\n\n/**\n * Representa una solicitud de descarga de CFDI o metadatos\n */\nexport interface DownloadRequest extends BaseDto {\n    /** Número consecutivo de la solicitud */\n    consecutive?: number;\n  \n    /** \n     * ID de solicitud SAT utilizado para rastrear la solicitud en el sistema SAT\n     */\n    satRequestId?: string;\n  \n    /** \n     * ID de la regla asociada con la solicitud\n     */\n    downloadRuleId?: string;\n  \n    /** ID del tipo de descarga */\n    downloadTypeId?: string;\n    \n    /** Catálogo del tipo de descarga */\n    downloadType?: CatalogDto;\n  \n    /** ID del tipo de solicitud de descarga */\n    downloadRequestTypeId?: string;\n    \n    /** Catálogo del tipo de solicitud de descarga */\n    downloadRequestType?: CatalogDto;\n  \n    /** \n     * RFC Receptor\n     * CFDI específicos o metadatos del RFC receptor dado\n     */\n    recipientTin?: string;\n  \n    /** \n     * RFC Emisor\n     * CFDI específicos o metadatos del RFC emisor dado\n     */\n    issuerTin?: string;\n  \n    /** \n     * RFC Solicitante\n     * RFC quien está solicitando la consulta\n     */\n    requesterTin?: string;\n  \n    /** \n     * Fecha inicial\n     * Fecha de inicio para la solicitud asociada\n     */\n    startDate: DateTime;\n  \n    /** \n     * Fecha final\n     * Fecha de fin para la solicitud asociada\n     */\n    endDate: DateTime;\n  \n    /** \n     * Tipo de solicitud\n     * Tipo de solicitud para la petición\n     * CFDI o Metadata\n     */\n    satQueryTypeId?: string;\n    \n    /** Catálogo del tipo de consulta SAT */\n    satQueryType?: CatalogDto;\n  \n    /** \n     * Tipo de comprobante\n     * Tipo específico de factura a solicitar\n     * Ingreso, Egreso, Traslado, Nómina, Pago, Todos\n     */\n    satInvoiceTypeId?: string;\n    \n    /** Catálogo del tipo de factura SAT */\n    satInvoiceType?: CatalogDto;\n  \n    /** \n     * Estado del comprobante\n     * Estado de los CFDI a solicitar\n     */\n    satInvoiceStatusId?: string;\n    \n    /** Catálogo del estado de la factura SAT */\n    satInvoiceStatus?: CatalogDto;\n  \n    /** \n     * Complemento\n     * Complementos CFDI para la solicitud\n     */\n    satInvoiceComplementId?: string;\n    \n    /** Catálogo del complemento de factura SAT */\n    satInvoiceComplement?: CatalogDto;\n  \n    /** \n     * Estado actual de la solicitud\n     * DESCONOCIDO, ACEPTADA, EN PROCESO, TERMINADA, ERROR, RECHAZADA, VENCIDA\n     */\n    satRequestStatusId?: string;\n    \n    /** Catálogo del estado de la solicitud SAT */\n    satRequestStatus?: CatalogDto;\n  \n    /** \n     * ID del estado de la solicitud en Fiscalapi\n     */\n    downloadRequestStatusId?: string;\n    \n    /** Catálogo del estado de la solicitud de descarga */\n    downloadRequestStatus?: CatalogDto;\n  \n    /** \n     * Fecha del último intento\n     * Fecha del último intento para la solicitud asociada\n     */\n    lastAttemptDate?: DateTime | string;\n  \n    /** \n     * Fecha del siguiente intento\n     * Fecha del siguiente intento para la solicitud asociada\n     */\n    nextAttemptDate?: DateTime | string;\n  \n    /** \n     * Número de CFDI encontrados para la solicitud cuando la solicitud está terminada\n     */\n    invoiceCount?: number;\n  \n    /** \n     * Lista de IDs de paquetes disponibles para descarga cuando la solicitud está terminada\n     */\n    packageIds?: string[];\n  \n    /** \n     * Indica si la solicitud está lista para descarga, se vuelve verdadero cuando la solicitud está terminada y los paquetes están disponibles\n     */\n    isReadyToDownload?: boolean;\n  \n    /** \n     * Número total de reintentos intentados para esta solicitud a través de todas las re-submisiones\n     */\n    retriesCount?: number;\n  }\n\n  /**\n * Representa un elemento de metadatos de CFDI descargado desde el SAT\n */\nexport interface MetadataItem extends BaseDto {\n    /** \n     * Folio de la factura - UUID\n     */\n    invoiceUuid?: string;\n  \n    /** \n     * RFC del emisor del comprobante - RfcEmisor\n     */\n    issuerTin?: string;\n  \n    /** \n     * Nombre o razón social del emisor - NombreEmisor\n     */\n    issuerName?: string;\n  \n    /** \n     * RFC del receptor del comprobante - RfcReceptor\n     */\n    recipientTin?: string;\n  \n    /** \n     * Nombre o razón social del receptor - NombreReceptor\n     */\n    recipientName?: string;\n  \n    /** \n     * RFC del Proveedor Autorizado de Certificación (PAC) - RfcPac\n     */\n    pacTin?: string;\n  \n    /** \n     * Fecha y hora de emisión del comprobante - FechaEmision\n     */\n    invoiceDate: DateTime | string;\n  \n    /** \n     * Fecha y hora de certificación por el SAT - FechaCertificacionSat\n     */\n    satCertificationDate: DateTime | string;\n  \n    /** \n     * Monto total del comprobante - Monto\n     */\n    amount?: number;\n  \n    /** \n     * Tipo de comprobante (I = Ingreso, E = Egreso, T = Traslado, N = Nómina, P = Pago) - EfectoComprobante\n     */\n    invoiceType?: string;\n  \n    /** \n     * Estatus del comprobante (1 = Vigente, 0 = Cancelado) - Estatus\n     */\n    status?: number;\n  \n    /** \n     * Fecha de cancelación del comprobante (si aplica) - FechaCancelacion\n     */\n    cancellationDate?: DateTime | string;\n  \n    /** ID del paquete de descarga */\n    downloadPackageId?: string;\n    \n    /** ID de la solicitud de descarga */\n    downloadRequestId?: string;\n  }\n\n  /**\n * Representa el XML de un CFDI (Comprobante Fiscal Digital por Internet) descargado desde el SAT\n */\nexport interface Xml extends BaseDto {\n    /** ID de la solicitud de descarga */\n    downloadRequestId?: string;\n  \n    /** Versión del CFDI */\n    version?: string;\n  \n    /** Serie */\n    series?: string;\n  \n    /** Folio */\n    number?: string;\n  \n    /** Fecha de emisión del CFDI */\n    date: DateTime | string;\n  \n    /** Código de la forma de pago */\n    paymentForm?: string;\n  \n    /** Código del método de pago */\n    paymentMethod?: string;\n  \n    /** Número de certificado del emisor */\n    certificateNumber?: string;\n  \n    /** Condiciones de pago */\n    paymentConditions?: string;\n  \n    /** Subtotal del CFDI */\n    subTotal?: number;\n  \n    /** Descuento aplicado al CFDI */\n    discount?: number;\n  \n    /** Código de la moneda del CFDI */\n    currency?: string;\n  \n    /** Tipo de cambio del CFDI (si aplica) */\n    exchangeRate?: number;\n  \n    /** Total del CFDI */\n    total?: number;\n  \n    /** Tipo de comprobante (I = Ingreso, E = Egreso, T = Traslado, N = Nómina, P = Pago) */\n    invoiceType?: string;\n  \n    /** Código de exportación (si aplica) */\n    export?: string;\n  \n    /** Lugar de expedición del CFDI */\n    expeditionZipCode?: string;\n  \n    /** Confirmación si aplica */\n    confirmation?: string;\n  \n    /** Total impuestos retenidos */\n    totalWithheldTaxes?: number;\n  \n    /** Total impuestos trasladados */\n    totalTransferredTaxes?: number;\n  \n    /** Información global del CFDI (para CFDI globales) */\n    xmlGlobalInformation?: XmlGlobalInformation;\n  \n    /** Información de impuestos del CFDI */\n    taxes?: XmlTax[];\n  \n    /** Información sobre facturas relacionadas del CFDI (CFDI relacionados) */\n    xmlRelated?: XmlRelated[];\n  \n    /** Información del emisor del CFDI */\n    xmlIssuer?: XmlIssuer;\n  \n    /** Información del receptor del CFDI */\n    xmlRecipient?: XmlRecipient;\n  \n    /** Información de los conceptos del CFDI */\n    xmlItems?: XmlItem[];\n  \n    /** Información de los complementos del CFDI */\n    xmlComplements?: XmlComplement[];\n  \n    /** XML crudo en base64 */\n    base64Content?: string;\n  }\n  \n  /**\n   * Información global del CFDI\n   */\n  export interface XmlGlobalInformation extends BaseDto {\n    /** Periodicidad */\n    periodicity?: string;\n  \n    /** Mes */\n    month?: string;\n  \n    /** Año */\n    year?: number;\n  }\n  \n  /**\n   * Información del emisor del CFDI\n   */\n  export interface XmlIssuer extends BaseDto {\n    /** RFC del emisor */\n    tin?: string;\n  \n    /** Razón social */\n    legalName?: string;\n  \n    /** Régimen fiscal */\n    taxRegime?: string;\n  }\n  \n  /**\n   * Información aduanera del concepto\n   */\n  export interface XmlItemCustomsInformation extends BaseDto {\n    /** ID del concepto XML */\n    xmlItemId?: string;\n  \n    /** Número de documento aduanero */\n    customsDocumentNumber?: string;\n  }\n  \n  /**\n   * Concepto del CFDI\n   */\n  export interface XmlItem extends BaseDto {\n    /** ID del XML */\n    xmlId?: string;\n  \n    /** Código del concepto */\n    itemCode?: string;\n  \n    /** SKU del concepto */\n    sku?: string;\n  \n    /** Cantidad */\n    quantity?: number;\n  \n    /** Unidad de medida */\n    unitMeasurement?: string;\n  \n    /** Descripción */\n    description?: string;\n  \n    /** Precio unitario */\n    unitPrice?: number;\n  \n    /** Importe */\n    amount?: number;\n  \n    /** Descuento */\n    discount?: number;\n  \n    /** Objeto de impuesto */\n    taxObject?: string;\n  \n    /** Cuenta de terceros */\n    thirdPartyAccount?: string;\n  \n    /** Información aduanera del concepto */\n    xmlItemCustomsInformation?: XmlItemCustomsInformation[];\n  \n    /** Cuentas prediales del concepto */\n    xmlItemPropertyAccounts?: XmlItemPropertyAccount[];\n  \n    /** Impuestos del concepto */\n    taxes?: XmlItemTax[];\n  }\n  \n  /**\n   * Cuenta predial del concepto\n   */\n  export interface XmlItemPropertyAccount extends BaseDto {\n    /** ID del concepto XML */\n    xmlItemId?: string;\n  \n    /** Número de cuenta predial */\n    propertyAccountNumber?: string;\n  }\n  \n  /**\n   * Impuesto del concepto\n   */\n  export interface XmlItemTax extends BaseDto {\n    /** Base del impuesto */\n    base?: number;\n  \n    /** Código del impuesto */\n    tax?: string;\n  \n    /** Tipo de impuesto */\n    taxType?: string;\n  \n    /** Tasa o cuota */\n    rate?: number;\n  \n    /** Importe del impuesto */\n    amount?: number;\n  \n    /** Naturaleza del impuesto (T = Traslado, R = Retención) */\n    taxFlag?: string;\n  \n    /** ID del concepto XML */\n    xmlItemId?: string;\n  }\n  \n  /**\n   * Información del receptor del CFDI\n   */\n  export interface XmlRecipient extends BaseDto {\n    /** RFC del receptor */\n    tin?: string;\n  \n    /** Razón social */\n    legalName?: string;\n  \n    /** Código postal */\n    zipCode?: string;\n  \n    /** Régimen fiscal */\n    taxRegime?: string;\n  \n    /** Uso del CFDI */\n    cfdiUse?: string;\n  \n    /** ID fiscal extranjero */\n    foreignTaxId?: string;\n  \n    /** Residencia fiscal */\n    fiscalResidence?: string;\n  }\n  \n  /**\n   * CFDI relacionado\n   */\n  export interface XmlRelated extends BaseDto {\n    /** ID del XML */\n    xmlId?: string;\n  \n    /** Tipo de relación */\n    relationshipType?: string;\n  \n    /** UUID del CFDI relacionado */\n    cfdiUuid?: string;\n  }\n  \n  /**\n   * Impuesto del CFDI\n   */\n  export interface XmlTax extends BaseDto {\n    /** Base del impuesto */\n    base?: number;\n  \n    /** Código del impuesto */\n    tax?: string;\n  \n    /** Tipo de impuesto */\n    taxType?: string;\n  \n    /** Tasa o cuota */\n    rate?: number;\n  \n    /** Importe del impuesto */\n    amount?: number;\n  \n    /** Naturaleza del impuesto (T = Traslado, R = Retención) */\n    taxFlag?: string;\n  \n    /** ID del XML */\n    xmlId?: string;\n  }\n  \n  /**\n   * Complemento del CFDI\n   */\n  export interface XmlComplement extends BaseDto {\n    /** Nombre del complemento */\n    complementName?: string;\n  \n    /** Valor del complemento en base64 */\n    base64ComplementValue?: string;\n  \n    /** ID del XML */\n    xmlId?: string;\n  }"]}

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

@@ -0,0 +1,35 @@
+/**
+ * Implementación del servicio de catálogos de descarga masiva
+ */
+export class DownloadCatalogService {
+    constructor(httpClient, apiVersion = 'v4') {
+        this.httpClient = httpClient;
+        this.apiVersion = apiVersion;
+        this.baseEndpoint = `api/${apiVersion}/download-catalogs`;
+    }
+    /**
+     * Construye el endpoint completo para las peticiones
+     * @param path - Ruta adicional opcional
+     * @returns URL completa del endpoint
+     */
+    buildEndpoint(path) {
+        return path ? `${this.baseEndpoint}/${path}` : this.baseEndpoint;
+    }
+    /**
+     * GET /api/v4/download-catalogs
+     * Recupera todos los nombres de los catálogos de descarga masiva disponibles
+     */
+    async getList() {
+        const endpoint = this.buildEndpoint();
+        return this.httpClient.getAsync(endpoint);
+    }
+    /**
+     * GET /api/v4/download-catalogs/{catalogName}
+     * Lista todos los registros de un catálogo específico
+     */
+    async listCatalog(catalogName) {
+        const endpoint = this.buildEndpoint(catalogName);
+        return this.httpClient.getAsync(endpoint);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/services/download-request.service.js

@@ -0,0 +1,88 @@
+import { BaseFiscalapiService } from './base-fiscalapi-service';
+/**
+ * Implementación del servicio de solicitudes de descarga masiva
+ */
+export class DownloadRequestService extends BaseFiscalapiService {
+    /**
+     * Crea una nueva instancia del servicio de solicitudes de descarga masiva
+     * @param {IFiscalapiHttpClient} httpClient - Cliente HTTP
+     * @param {string} apiVersion - Versión de la API
+     */
+    constructor(httpClient, apiVersion) {
+        super(httpClient, 'download-requests', apiVersion);
+    }
+    /**
+     * Lista los xmls descargados para un requestId.
+     *
+     * @param requestId - ID de la solicitud
+     * @returns Lista paginada de objetos Xml
+     */
+    getXmlsAsync(requestId) {
+        // GET /api/v4/download-requests/<requestId>/xmls
+        const path = `${requestId}/xmls`;
+        const endpoint = this.buildEndpoint(path);
+        return this.httpClient.getAsync(endpoint);
+    }
+    /**
+     * Lista los meta-items descargados para un requestId.
+     *
+     * @param requestId - ID de la solicitud
+     * @returns Lista paginada de objetos MetadataItem
+     */
+    getMetadataItemsAsync(requestId) {
+        // GET /api/v4/download-requests/<requestId>/meta-items
+        const path = `${requestId}/meta-items`;
+        const endpoint = this.buildEndpoint(path);
+        return this.httpClient.getAsync(endpoint);
+    }
+    /**
+     * Downloads la lista de paquetes (archivos .zip) de un requestId.
+     *
+     * @param requestId - ID de la solicitud
+     * @returns Lista de FileResponses
+     */
+    downloadPackageAsync(requestId) {
+        // GET /api/v4/download-requests/<requestId>/package
+        const path = `${requestId}/package`;
+        const endpoint = this.buildEndpoint(path);
+        return this.httpClient.getAsync(endpoint);
+    }
+    /**
+     * Descarga el archivo crudo de solicitud SAT para un requestId.
+     *
+     * @param requestId - ID de la solicitud
+     * @returns Objeto de respuesta de archivo
+     */
+    downloadSatRequestAsync(requestId) {
+        // GET /api/v4/download-requests/<requestId>/raw-request
+        const path = `${requestId}/raw-request`;
+        const endpoint = this.buildEndpoint(path);
+        return this.httpClient.getAsync(endpoint);
+    }
+    /**
+     * Descarga la respuesta SAT para un requestId.
+     *
+     * @param requestId - ID de la solicitud
+     * @returns Objeto de respuesta de archivo
+     */
+    downloadSatResponseAsync(requestId) {
+        // GET /api/v4/download-requests/<requestId>/raw-response
+        const path = `${requestId}/raw-response`;
+        const endpoint = this.buildEndpoint(path);
+        return this.httpClient.getAsync(endpoint);
+    }
+    /**
+     * Busca solicitudes de descarga creadas en una fecha específica.
+     *
+     * @param createdAt - Fecha de creación
+     * @returns Lista de solicitudes de descarga
+     */
+    searchAsync(createdAt) {
+        // GET /api/v4/download-requests/search?createdAt=2025-08-21
+        const formattedDate = createdAt.toISOString().split('T')[0]; // Format as YYYY-MM-DD
+        const path = `search?createdAt=${formattedDate}`;
+        const endpoint = this.buildEndpoint(path);
+        return this.httpClient.getAsync(endpoint);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/services/download-rule.service.js

@@ -0,0 +1,26 @@
+import { BaseFiscalapiService } from './base-fiscalapi-service';
+/**
+ * Implementación del servicio de reglas de descarga masiva
+ */
+export class DownloadRuleService extends BaseFiscalapiService {
+    /**
+  * Crea una nueva instancia del servicio de reglas de descarga masiva
+     * @param {IFiscalapiHttpClient} httpClient - Cliente HTTP
+     * @param {string} apiVersion - Versión de la API
+     */
+    constructor(httpClient, apiVersion) {
+        super(httpClient, 'download-rules', apiVersion);
+    }
+    /**
+     * Crea una regla y una solicitud de descarga masiva de prueba.
+     *
+     * @returns solicitud de descarga masiva de prueba
+     */
+    createTestRule() {
+        // GET /api/v4/download-rules/test
+        var path = "test";
+        var endpoint = this.buildEndpoint(path);
+        return this.httpClient.postAsync(endpoint, {});
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,10 +1,13 @@
 import { FiscalapiHttpClientFactory } from '../http/fiscalapi-http-client-factory';
 import { ApiKeyService } from './api-key-service';
 import { CatalogService } from './catalog-service';
+import { DownloadCatalogService } from './download-catalog.service';
 import { InvoiceService } from './invoice-service';
 import { PersonService } from './person-service';
 import { ProductService } from './product-service';
 import { TaxFileService } from './tax-file-service';
+import { DownloadRuleService } from './download-rule.service';
+import { DownloadRequestService } from './download-request.service';
 /**
  * Cliente principal para FiscalAPI
  */
@@ -25,6 +28,9 @@ export class FiscalapiClient {
         this.apiKeys = new ApiKeyService(httpClient, apiVersion);
         this.catalogs = new CatalogService(httpClient, apiVersion);
         this.taxFiles = new TaxFileService(httpClient, apiVersion);
+        this.downloadCatalogs = new DownloadCatalogService(httpClient, apiVersion);
+        this.downloadRules = new DownloadRuleService(httpClient, apiVersion);
+        this.downloadRequests = new DownloadRequestService(httpClient, apiVersion);
     }
     /**
      * Crea una nueva instancia del cliente de FiscalAPI
@@ -60,4 +66,4 @@ export class FiscalapiClient {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fiscalapi-client.js","sourceRoot":"","sources":["../../../src/services/fiscalapi-client.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,0BAA0B,EAAE,MAAM,uCAAuC,CAAC;AACnF,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACpE,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAE9D,OAAO,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AAGpE;;GAEG;AACH,MAAM,OAAO,eAAe;IA8C1B;;;;OAIG;IACH,YAAoB,QAA2B;QAC7C,uBAAuB;QACvB,MAAM,UAAU,GAAG,0BAA0B,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAC/D,MAAM,UAAU,GAAG,QAAQ,CAAC,UAAU,IAAI,IAAI,CAAC;QAE/C,2BAA2B;QAC3B,IAAI,CAAC,QAAQ,GAAG,IAAI,cAAc,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;QAC3D,IAAI,CAAC,QAAQ,GAAG,IAAI,cAAc,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;QAC3D,IAAI,CAAC,OAAO,GAAG,IAAI,aAAa,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;QACzD,IAAI,CAAC,OAAO,GAAG,IAAI,aAAa,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;QACzD,IAAI,CAAC,QAAQ,GAAG,IAAI,cAAc,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;QAC3D,IAAI,CAAC,QAAQ,GAAG,IAAI,cAAc,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;QAC3D,IAAI,CAAC,gBAAgB,GAAG,IAAI,sBAAsB,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;QAC3E,IAAI,CAAC,aAAa,GAAG,IAAI,mBAAmB,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;QACrE,IAAI,CAAC,gBAAgB,GAAG,IAAI,sBAAsB,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;IAC7E,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,MAAM,CAAC,QAA2B;QACvC,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;QACrE,CAAC;QAED,0BAA0B;QAC1B,eAAe,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC;QAE3C,oEAAoE;QACpE,QAAQ,CAAC,UAAU,GAAG,QAAQ,CAAC,UAAU,IAAI,IAAI,CAAC;QAClD,QAAQ,CAAC,QAAQ,GAAG,QAAQ,CAAC,QAAQ,IAAI,qBAAqB,CAAC;QAC/D,QAAQ,CAAC,KAAK,GAAG,QAAQ,CAAC,KAAK,IAAI,KAAK,CAAC;QAEzC,OAAO,IAAI,eAAe,CAAC,QAAQ,CAAC,CAAC;IACvC,CAAC;IAED;;;;OAIG;IACK,MAAM,CAAC,gBAAgB,CAAC,QAA2B;QACzD,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;YACrB,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;QACzC,CAAC;QAED,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;YACrB,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;QACzC,CAAC;QAED,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;YACrB,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;QACzC,CAAC;IACH,CAAC;CACF","sourcesContent":["\n\nimport { IFiscalapiClient } from '../abstractions/fiscalapi-client.interface';\nimport { IInvoiceService } from '../abstractions/invoice-service.interface';\nimport { IProductService } from '../abstractions/product-service.interface';\nimport { IPersonService } from '../abstractions/person-service.interface';\nimport { IApiKeyService } from '../abstractions/api-key-service.interface';\nimport { ICatalogService } from '../abstractions/catalog-service.interface';\nimport { ITaxFileService } from '../abstractions/tax-file-service.interface';\nimport { IDownloadCatalogService } from '../abstractions/download-catalog.inteface';\nimport { FiscalapiSettings } from '../common/fiscalapi-settings';\nimport { FiscalapiHttpClientFactory } from '../http/fiscalapi-http-client-factory';\nimport { ApiKeyService } from './api-key-service';\nimport { CatalogService } from './catalog-service';\nimport { DownloadCatalogService } from './download-catalog.service';\nimport { InvoiceService } from './invoice-service';\nimport { PersonService } from './person-service';\nimport { ProductService } from './product-service';\nimport { TaxFileService } from './tax-file-service';\nimport { DownloadRuleService } from './download-rule.service';\nimport { IDownloadRuleService } from '../abstractions/download-rule.service.inteface';\nimport { DownloadRequestService } from './download-request.service';\nimport { IDownloadRequestService } from '../abstractions/download-request.service.interface';\n\n/**\n * Cliente principal para FiscalAPI\n */\nexport class FiscalapiClient implements IFiscalapiClient {\n  /**\n   * Servicio de facturas\n   */\n  readonly invoices: IInvoiceService;\n  \n  /**\n   * Servicio de productos\n   */\n  readonly products: IProductService;\n  \n  /**\n   * Servicio de personas\n   */\n  readonly persons: IPersonService;\n  \n  /**\n   * Servicio de claves de API\n   */\n  readonly apiKeys: IApiKeyService;\n  \n  /**\n   * Servicio de catálogos\n   */\n  readonly catalogs: ICatalogService;\n  \n  /**\n   * Servicio de archivos fiscales\n   */\n  readonly taxFiles: ITaxFileService;\n\n  /**\n   * Servicio de catálogos de descarga masiva\n   */\n  readonly downloadCatalogs: IDownloadCatalogService;\n\n  /**\n   * Servicio de reglas de descarga masiva\n   */\n  readonly downloadRules: IDownloadRuleService;\n\n  /**\n   * Servicio de solicitudes de descarga masiva\n   */\n  readonly downloadRequests: IDownloadRequestService;\n\n  /**\n   * Crea una nueva instancia del cliente de FiscalAPI\n   * @param {FiscalapiSettings} settings - Configuración\n   * @private\n   */\n  private constructor(settings: FiscalapiSettings) {\n    // Crea el cliente HTTP\n    const httpClient = FiscalapiHttpClientFactory.create(settings);\n    const apiVersion = settings.apiVersion || 'v4';\n    \n    // Inicializa los servicios\n    this.invoices = new InvoiceService(httpClient, apiVersion);\n    this.products = new ProductService(httpClient, apiVersion);\n    this.persons = new PersonService(httpClient, apiVersion);\n    this.apiKeys = new ApiKeyService(httpClient, apiVersion);\n    this.catalogs = new CatalogService(httpClient, apiVersion);\n    this.taxFiles = new TaxFileService(httpClient, apiVersion);\n    this.downloadCatalogs = new DownloadCatalogService(httpClient, apiVersion);\n    this.downloadRules = new DownloadRuleService(httpClient, apiVersion);\n    this.downloadRequests = new DownloadRequestService(httpClient, apiVersion);\n  }\n\n  /**\n   * Crea una nueva instancia del cliente de FiscalAPI\n   * @param {FiscalapiSettings} settings - Configuración\n   * @returns {IFiscalapiClient} Instancia del cliente de FiscalAPI\n   */\n  static create(settings: FiscalapiSettings): IFiscalapiClient {\n    if (!settings) {\n      throw new Error('La configuración no puede ser nula o indefinida');\n    }\n    \n    // Valida la configuración\n    FiscalapiClient.validateSettings(settings);\n    \n    // Establece valores predeterminados para configuraciones opcionales\n    settings.apiVersion = settings.apiVersion || 'v4';\n    settings.timeZone = settings.timeZone || 'America/Mexico_City';\n    settings.debug = settings.debug || false;\n    \n    return new FiscalapiClient(settings);\n  }\n\n  /**\n   * Valida la configuración\n   * @param {FiscalapiSettings} settings - Configuración\n   * @private\n   */\n  private static validateSettings(settings: FiscalapiSettings): void {\n    if (!settings.apiUrl) {\n      throw new Error('apiUrl es requerido');\n    }\n    \n    if (!settings.apiKey) {\n      throw new Error('apiKey es requerido');\n    }\n    \n    if (!settings.tenant) {\n      throw new Error('tenant es requerido');\n    }\n  }\n}\n"]}

package/dist/types/abstractions/download-catalog.inteface.d.ts

@@ -0,0 +1,22 @@
+import { ApiResponse } from "../common/api-response";
+import { CatalogDto } from "../common/catalog-dto";
+/**
+ * Interfaz del servicio de catálogos de descarga masiva
+ */
+export interface IDownloadCatalogService {
+    /**
+     * GET /api/v4/download-catalogs
+     * Recupera todos los nombres de los catálogos de descarga masiva disponibles para listarlos individualmente por nombre.
+     *
+     * @returns Lista de nombres de catálogos disponibles
+     */
+    getList(): Promise<ApiResponse<string[]>>;
+    /**
+     * GET /api/v4/download-catalogs/{catalogName}
+     * Lista todos los registros de un catálogo pasando el nombre del catálogo
+     *
+     * @param catalogName - Nombre del catálogo
+     * @returns Lista de registros del catálogo
+     */
+    listCatalog(catalogName: string): Promise<ApiResponse<CatalogDto[]>>;
+}

package/dist/types/abstractions/download-request.service.interface.d.ts

@@ -0,0 +1,52 @@
+import { IFiscalapiService } from './fiscalapi-service.interface';
+import { DownloadRequest, Xml, MetadataItem } from '../models/download';
+import { ApiResponse } from '../common/api-response';
+import { PagedList } from '../common/paged-list';
+import { FileResponse } from '../common/file-response';
+/**
+ * Interfaz del servicio de solicitudes de descarga masiva
+ */
+export interface IDownloadRequestService extends IFiscalapiService<DownloadRequest> {
+    /**
+     * Lista los xmls descargados para un requestId.
+     *
+     * @param requestId - ID de la solicitud
+     * @returns Lista paginada de objetos Xml
+     */
+    getXmlsAsync(requestId: string): Promise<ApiResponse<PagedList<Xml>>>;
+    /**
+     * Lista los meta-items descargados para un requestId.
+     *
+     * @param requestId - ID de la solicitud
+     * @returns Lista paginada de objetos MetadataItem
+     */
+    getMetadataItemsAsync(requestId: string): Promise<ApiResponse<PagedList<MetadataItem>>>;
+    /**
+     * Downloads la lista de paquetes (archivos .zip) de un requestId.
+     *
+     * @param requestId - ID de la solicitud
+     * @returns Lista de FileResponses
+     */
+    downloadPackageAsync(requestId: string): Promise<ApiResponse<FileResponse[]>>;
+    /**
+     * Descarga el archivo crudo de solicitud SAT para un requestId.
+     *
+     * @param requestId - ID de la solicitud
+     * @returns Objeto de respuesta de archivo
+     */
+    downloadSatRequestAsync(requestId: string): Promise<ApiResponse<FileResponse>>;
+    /**
+     * Descarga la respuesta SAT para un requestId.
+     *
+     * @param requestId - ID de la solicitud
+     * @returns Objeto de respuesta de archivo
+     */
+    downloadSatResponseAsync(requestId: string): Promise<ApiResponse<FileResponse>>;
+    /**
+     * Busca solicitudes de descarga creadas en una fecha específica.
+     *
+     * @param createdAt - Fecha de creación
+     * @returns Lista de solicitudes de descarga
+     */
+    searchAsync(createdAt: Date): Promise<ApiResponse<DownloadRequest[]>>;
+}

package/dist/types/abstractions/download-rule.service.inteface.d.ts

@@ -0,0 +1,15 @@
+import { IFiscalapiService } from './fiscalapi-service.interface';
+import { DownloadRequest, DownloadRule } from '../models/download';
+import { ApiResponse } from '../common/api-response';
+/**
+ * Interfaz del servicio de reglas de descarga masiva
+ */
+export interface IDownloadRuleService extends IFiscalapiService<DownloadRule> {
+    /**
+     * GET /api/v4/download-rules/test
+     * Crea una regla de descarga masiva de prueba
+     *
+     * @returns Regla de descarga masiva de prueba
+     */
+    createTestRule(): Promise<ApiResponse<DownloadRequest>>;
+}

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

@@ -1,5 +1,8 @@
 import { IApiKeyService } from './api-key-service.interface';
 import { ICatalogService } from './catalog-service.interface';
+import { IDownloadCatalogService } from './download-catalog.inteface';
+import { IDownloadRequestService } from './download-request.service.interface';
+import { IDownloadRuleService } from './download-rule.service.inteface';
 import { IInvoiceService } from './invoice-service.interface';
 import { IPersonService } from './person-service.interface';
 import { IProductService } from './product-service.interface';
@@ -32,4 +35,16 @@ export interface IFiscalapiClient {
      * Servicio de archivos fiscales
      */
     taxFiles: ITaxFileService;
+    /**
+     * Servicio de descarga masiva
+     */
+    downloadCatalogs: IDownloadCatalogService;
+    /**
+     * Servicio de reglas de descarga masiva
+     */
+    downloadRules: IDownloadRuleService;
+    /**
+     * Servicio de solicitudes de descarga masiva
+     */
+    downloadRequests: IDownloadRequestService;
 }

package/dist/types/index.d.ts

@@ -1,21 +1,23 @@
 export { FiscalapiClient } from './services/fiscalapi-client';
-export { IFiscalapiClient } from './abstractions/fiscalapi-client.interface';
-export { IFiscalapiService } from './abstractions/fiscalapi-service.interface';
-export { IApiKeyService } from './abstractions/api-key-service.interface';
-export { ICatalogService } from './abstractions/catalog-service.interface';
-export { IInvoiceService } from './abstractions/invoice-service.interface';
-export { IPersonService } from './abstractions/person-service.interface';
-export { IProductService } from './abstractions/product-service.interface';
-export { ITaxFileService } from './abstractions/tax-file-service.interface';
-export { ApiKey } from './models/api-key';
-export { Person } from './models/person';
-export { Product, ProductTax } from './models/product';
-export { TaxFile } from './models/tax-file';
-export { Invoice, InvoiceIssuer, InvoiceRecipient, InvoiceItem, InvoiceResponse, TaxCredential, RelatedInvoice, GlobalInformation, ItemTax, InvoicePayment, PaidInvoice, PaidInvoiceTax, CancelInvoiceRequest, CancelInvoiceResponse, InvoiceStatusRequest, InvoiceStatusResponse, CreatePdfRequest, SendInvoiceRequest } from './models/invoice';
-export { FiscalapiSettings } from './common/fiscalapi-settings';
-export { ApiResponse, ValidationFailure } from './common/api-response';
+export type { IFiscalapiClient } from './abstractions/fiscalapi-client.interface';
+export type { IFiscalapiService } from './abstractions/fiscalapi-service.interface';
+export type { IApiKeyService } from './abstractions/api-key-service.interface';
+export type { ICatalogService } from './abstractions/catalog-service.interface';
+export type { IInvoiceService } from './abstractions/invoice-service.interface';
+export type { IPersonService } from './abstractions/person-service.interface';
+export type { IProductService } from './abstractions/product-service.interface';
+export type { ITaxFileService } from './abstractions/tax-file-service.interface';
+export type { IDownloadCatalogService } from './abstractions/download-catalog.inteface';
+export type { ApiKey } from './models/api-key';
+export type { Person } from './models/person';
+export type { Product, ProductTax } from './models/product';
+export type { TaxFile } from './models/tax-file';
+export type { Invoice, InvoiceIssuer, TaxCredential, InvoiceRecipient, InvoiceItem, ItemTax, GlobalInformation, RelatedInvoice, InvoiceResponse, InvoicePayment, PaidInvoice, PaidInvoiceTax, CancelInvoiceRequest, CancelInvoiceResponse, CreatePdfRequest, SendInvoiceRequest, InvoiceStatusRequest, InvoiceStatusResponse, } from './models/invoice';
+export type { DownloadRule, DownloadRequest, MetadataItem, Xml, XmlGlobalInformation, XmlIssuer, XmlItemCustomsInformation, XmlItem, XmlItemPropertyAccount, XmlItemTax, XmlRecipient, XmlRelated, XmlTax, XmlComplement } from './models/download';
+export type { FiscalapiSettings } from './common/fiscalapi-settings';
+export type { ApiResponse, ValidationFailure, ProblemDetails } from './common/api-response';
+export type { FileResponse } from './common/file-response';
 export { PagedList } from './common/paged-list';
-export { FileResponse } from './common/file-response';
 export { BaseDto } from './common/base-dto';
 export { AuditableDto } from './common/auditable-dto';
 export { SerializableDto } from './common/serializable-dto';