nfewizard-io 0.3.0 → 0.3.2

package/dist/cjs/modules/dfe/nfe/services/NFERecepcaoEvento/NFERecepcaoEventoService.d.ts

@@ -0,0 +1,40 @@
+import { AxiosInstance } from 'axios';
+import Environment from '@Modules/environment/Environment.js';
+import Utility from '@Utils/Utility.js';
+import XmlBuilder from '@Adapters/XmlBuilder.js';
+import { EventoNFe, GenericObject, TipoEvento } from '@Types';
+import BaseNFE from '@Modules/dfe/base/BaseNFe.js';
+import { GerarConsultaImpl, NFERecepcaoEventoServiceImpl, SaveFilesImpl } from '@Interfaces';
+declare class NFERecepcaoEventoService extends BaseNFE implements NFERecepcaoEventoServiceImpl {
+    tpEvento: string;
+    modelo?: string;
+    xmlEventosNacionais: string[];
+    xmlEventosRegionais: string[];
+    xMotivoPorEvento: any[];
+    constructor(environment: Environment, utility: Utility, xmlBuilder: XmlBuilder, axios: AxiosInstance, saveFiles: SaveFilesImpl, gerarConsulta: GerarConsultaImpl);
+    /**
+     * Método para gerar o Id do evento
+     */
+    private getID;
+    /**
+     * Verifica se o evento será disparado para o ambiente nacional ou para o estado pré-definido
+     */
+    private isAmbienteNacional;
+    /**
+     * Retorna o nome do Evento
+     */
+    private getTipoEventoName;
+    private separaEventosPorAmbiente;
+    /**
+     * Criação do XML
+     */
+    private gerarXmlRecepcaoEvento;
+    private trataRetorno;
+    protected enviaEvento(evento: TipoEvento[], idLote: number, tipoAmbiente: number): Promise<any>;
+    Exec(data: EventoNFe): Promise<{
+        success: boolean;
+        xMotivos: any[];
+        response: GenericObject[];
+    }>;
+}
+export default NFERecepcaoEventoService;

package/dist/cjs/modules/dfe/nfe/services/NFERetornoAutorizacao/NFERetornoAutorizacaoService.d.ts

@@ -0,0 +1,51 @@
+import Environment from '@Modules/environment/Environment.js';
+import Utility from '@Utils/Utility.js';
+import XmlBuilder from '@Adapters/XmlBuilder.js';
+import BaseNFE from '@Modules/dfe/base/BaseNFe.js';
+import { ProtNFe } from '@Types';
+import { AxiosInstance } from 'axios';
+import { GerarConsultaImpl, NFERetornoAutorizacaoServiceImpl, SaveFilesImpl } from '@Interfaces';
+declare class NFERetornoAutorizacaoService extends BaseNFE implements NFERetornoAutorizacaoServiceImpl {
+    constructor(environment: Environment, utility: Utility, xmlBuilder: XmlBuilder, axios: AxiosInstance, saveFiles: SaveFilesImpl, gerarConsulta: GerarConsultaImpl);
+    protected gerarXml(data: string): string;
+    /**
+     * Busca o retorno da Autorização pelo número do recibo (nRec)
+     *
+     * @param {string} nRec - Número do recibo retornado pela SEFAZ ao emitir uma NFe em modo assíncrono.
+     * @param {any} xmlNFe - Array contendo as NFe do lote enviado à SEFAZ.
+     * @returns {Promise<string>} XML completo da NFe (já com protocolo de autorização).
+     */
+    getRetornoRecibo(nRec: string, xmlNFe: string[]): Promise<{
+        success: boolean;
+        message: any;
+        data: string[];
+    }>;
+    /**
+     * Agrega o protNFe ao restante da NFe gerada na emissão.
+     *
+     * @param {string} protNFe - Tag protNFe do XML em formato JSON.
+     * @param {any} xmlNFe - Array contendo as NFe do lote enviado à SEFAZ.
+     * @returns {} XML completo da NFe (já com protocolo de autorização).
+     */
+    private getXmlRetornoAutorizacao;
+    /**
+     * Retorna o XML completo da Autorização (já com o protocolo de autorização)
+     *
+     * @param {number} tipoEmissao - Informa se o tipo emissão foi síncrona ou assíncrona (0- Não / 1 - Sim).
+     * @param {string | undefined} nRec - Número do recibo retornado pela SEFAZ ao emitir uma NFe em modo assíncrono.
+     * @param {ProtNFe | undefined} protNFe - Tag protNFe do XML em formato JSON.
+     * @param {string[]} xmlNFe - Array contendo as NFe do lote enviado à SEFAZ.
+     * @returns {Promise<string>} XML completo da NFe (já com protocolo de autorização).
+     */
+    getXmlRetorno({ tipoEmissao, nRec, protNFe, xmlNFe }: {
+        tipoEmissao: number;
+        nRec?: string;
+        protNFe?: ProtNFe[];
+        xmlNFe: string[];
+    }): Promise<{
+        success: boolean;
+        message: any;
+        data: string[];
+    }>;
+}
+export default NFERetornoAutorizacaoService;

package/dist/cjs/modules/dfe/nfe/services/NFEStatusServico/NFEStatusServicoService.d.ts

@@ -0,0 +1,11 @@
+import Environment from '@Modules/environment/Environment.js';
+import XmlBuilder from '@Adapters/XmlBuilder.js';
+import Utility from '@Utils/Utility.js';
+import BaseNFE from '@Modules/dfe/base/BaseNFe.js';
+import { AxiosInstance } from 'axios';
+import { SaveFilesImpl, GerarConsultaImpl, NFEStatusServicoServiceImpl } from '@Interfaces';
+declare class NFEStatusServicoService extends BaseNFE implements NFEStatusServicoServiceImpl {
+    constructor(environment: Environment, utility: Utility, xmlBuilder: XmlBuilder, axios: AxiosInstance, saveFiles: SaveFilesImpl, gerarConsulta: GerarConsultaImpl);
+    protected gerarXml(): string;
+}
+export default NFEStatusServicoService;

package/dist/cjs/modules/dfe/nfe/services/NFeWizard/NFeWizardService.d.ts

@@ -0,0 +1,71 @@
+import { NFeWizardServiceImpl } from '@Interfaces';
+import { Cancelamento, CartaDeCorrecao, CienciaDaOperacao, ConfirmacaoDaOperacao, ConsultaNFe, DesconhecimentoDaOperacao, DFePorChaveNFe, DFePorNSU, DFePorUltimoNSU, EmailParams, EPEC, EventoNFe, InutilizacaoData, NFe, NFEGerarDanfeProps, NFeWizardProps, OperacaoNaoRealizada } from '@Types';
+declare class NFeWizardService implements NFeWizardServiceImpl {
+    private config;
+    private environment;
+    private utility;
+    private xmlBuilder;
+    private axios;
+    private saveFiles;
+    private gerarConsulta;
+    constructor();
+    NFE_LoadEnvironment({ config }: {
+        config: NFeWizardProps;
+    }): Promise<void>;
+    /**
+     * Status Serviço
+     */
+    NFE_ConsultaStatusServico(): Promise<any>;
+    /**
+     * Consulta Protocolo
+     */
+    NFE_ConsultaProtocolo(chave: string): Promise<any>;
+    /**
+     * Recepção de Eventos
+     */
+    NFE_RecepcaoEvento(evento: EventoNFe): Promise<any>;
+    NFE_EventoPrevioDeEmissaoEmContingencia(evento: EPEC): Promise<any>;
+    NFE_Cancelamento(evento: Cancelamento): Promise<any>;
+    NFE_CienciaDaOperacao(evento: CienciaDaOperacao): Promise<any>;
+    NFE_ConfirmacaoDaOperacao(evento: ConfirmacaoDaOperacao): Promise<any>;
+    NFE_OperacaoNaoRealizada(evento: OperacaoNaoRealizada): Promise<any>;
+    NFE_CartaDeCorrecao(evento: CartaDeCorrecao): Promise<any>;
+    NFE_DesconhecimentoDaOperacao(evento: DesconhecimentoDaOperacao): Promise<any>;
+    /**
+     * Distribuição DFe
+     */
+    NFE_DistribuicaoDFe(data: ConsultaNFe): Promise<any>;
+    NFE_DistribuicaoDFePorUltNSU(data: DFePorUltimoNSU): Promise<any>;
+    NFE_DistribuicaoDFePorNSU(data: DFePorNSU): Promise<any>;
+    NFE_DistribuicaoDFePorChave(data: DFePorChaveNFe): Promise<any>;
+    /**
+     * Autorização
+     */
+    NFE_Autorizacao(data: NFe): Promise<any>;
+    NFCE_Autorizacao(data: NFe): Promise<any>;
+    /**
+     * Inutilização
+     */
+    NFE_Inutilizacao(data: InutilizacaoData): Promise<any>;
+    /**
+     * DANFE
+     */
+    NFE_GerarDanfe(data: NFEGerarDanfeProps): Promise<{
+        message: string;
+        success: boolean;
+    }>;
+    NFCE_GerarDanfe(data: NFEGerarDanfeProps): Promise<{
+        message: string;
+        success: boolean;
+    }>;
+    /**
+     * Método para envio de e-mail
+     * @param {EmailParams} mailParams - Mensagem de texto (aceita html)
+     */
+    NFE_EnviaEmail(mailParams: EmailParams): void;
+    /**
+     * Validação de ambiente
+     */
+    private validateEnvironment;
+}
+export default NFeWizardService;

package/dist/cjs/modules/environment/AxiosHttpClient.d.ts

@@ -0,0 +1,6 @@
+import { HttpClient, HttpClientConfig } from '@Interfaces';
+import { AxiosInstance } from 'axios';
+declare class AxiosHttpClient implements HttpClient<AxiosInstance> {
+    create(config: HttpClientConfig): AxiosInstance;
+}
+export default AxiosHttpClient;

package/dist/cjs/{classes → modules/environment}/Environment.d.ts

@@ -1,5 +1,6 @@
 import https from 'https';
-import { NFeWizardProps } from '@Protocols';
+import { NFeWizardProps } from 'src/core/types';
+import { AxiosInstance } from 'axios';
 declare class Environment {
     config: NFeWizardProps;
     certificate: string;
@@ -12,12 +13,8 @@ declare class Environment {
     getCertKey(): string;
     getCert(): string;
     getHttpAgent(): https.Agent;
-    private checkRequiredSettings;
-    private loadCertificateWithPEM;
-    private loadCertificateWithNodeForge;
-    private configAxios;
     loadEnvironment(): Promise<{
-        axios: import("axios").AxiosInstance;
+        axios: AxiosInstance;
     }>;
 }
 export default Environment;

package/dist/cjs/modules/environment/HttpClientBuilder.d.ts

@@ -0,0 +1,11 @@
+import { NFeWizardProps } from '@Types';
+import https from 'https';
+import { HttpClient } from '@Interfaces';
+declare class HttpClientBuilder<T> {
+    private config;
+    private agent;
+    private httpClient;
+    constructor(config: NFeWizardProps, agent: https.Agent, httpClient: HttpClient<T>);
+    createHttpClient(): T;
+}
+export default HttpClientBuilder;

package/dist/cjs/modules/environment/LoadCertificate.d.ts

@@ -0,0 +1,11 @@
+import { CertificateLoadReturn, NFeWizardProps } from '@Types';
+declare class LoadCertificate {
+    private config;
+    private certificate;
+    private cert_key;
+    constructor(config: NFeWizardProps);
+    private loadCertificateWithPEM;
+    private loadCertificateWithNodeForge;
+    loadCertificate(): Promise<CertificateLoadReturn>;
+}
+export default LoadCertificate;

package/dist/cjs/modules/environment/ValidateEnvironment.d.ts

@@ -0,0 +1,9 @@
+import { NFeWizardProps } from '@Types';
+declare class ValidateEnvironment {
+    checkRequiredSettings(config: NFeWizardProps): {
+        missingConfigurations: any;
+        message: string;
+        success: boolean;
+    };
+}
+export default ValidateEnvironment;

package/dist/esm/adapters/MailAdapter.d.ts

@@ -0,0 +1,10 @@
+import Environment from '@Modules/environment/Environment.js';
+import { EmailParams } from 'src/core/types';
+declare class MailController {
+    private environment;
+    constructor(environment: Environment);
+    private createTransporter;
+    private mountMail;
+    sendEmail(mailParams: EmailParams): void;
+}
+export default MailController;

package/dist/esm/adapters/NFeWizard.d.ts

@@ -0,0 +1,66 @@
+import { NFeWizardProps, EventoNFe, ConsultaNFe, NFe, InutilizacaoData, NFEGerarDanfeProps, DFePorChaveNFe, DFePorUltimoNSU, DFePorNSU, Cancelamento, CienciaDaOperacao, ConfirmacaoDaOperacao, OperacaoNaoRealizada, CartaDeCorrecao, DesconhecimentoDaOperacao, EPEC, EmailParams } from 'src/core/types';
+import { NFeWizardImpl } from '@Interfaces';
+export default class NFeWizard implements NFeWizardImpl {
+    private nfeWizardService;
+    constructor();
+    NFE_LoadEnvironment({ config }: {
+        config: NFeWizardProps;
+    }): Promise<void>;
+    /**
+     * Status Serviço
+     */
+    NFE_ConsultaStatusServico(): Promise<any>;
+    /**
+     * Consulta Protocolo
+     */
+    NFE_ConsultaProtocolo(chave: string): Promise<any>;
+    /**
+     * Recepção de Eventos
+     */
+    NFE_RecepcaoEvento(evento: EventoNFe): Promise<import("src/core/types").GenericObject[]>;
+    NFE_EventoPrevioDeEmissaoEmContingencia(evento: EPEC): Promise<import("src/core/types").GenericObject[]>;
+    NFE_Cancelamento(evento: Cancelamento): Promise<import("src/core/types").GenericObject[]>;
+    NFE_CienciaDaOperacao(evento: CienciaDaOperacao): Promise<import("src/core/types").GenericObject[]>;
+    NFE_ConfirmacaoDaOperacao(evento: ConfirmacaoDaOperacao): Promise<import("src/core/types").GenericObject[]>;
+    NFE_OperacaoNaoRealizada(evento: OperacaoNaoRealizada): Promise<import("src/core/types").GenericObject[]>;
+    NFE_CartaDeCorrecao(evento: CartaDeCorrecao): Promise<import("src/core/types").GenericObject[]>;
+    NFE_DesconhecimentoDaOperacao(evento: DesconhecimentoDaOperacao): Promise<import("src/core/types").GenericObject[]>;
+    /**
+     * Distribuição DFe
+     */
+    NFE_DistribuicaoDFe(data: ConsultaNFe): Promise<import("src/core/types").GenericObject>;
+    NFE_DistribuicaoDFePorUltNSU(data: DFePorUltimoNSU): Promise<import("src/core/types").GenericObject>;
+    NFE_DistribuicaoDFePorNSU(data: DFePorNSU): Promise<import("src/core/types").GenericObject>;
+    NFE_DistribuicaoDFePorChave(data: DFePorChaveNFe): Promise<import("src/core/types").GenericObject>;
+    /**
+     * Autorização
+     */
+    NFE_Autorizacao(data: NFe): Promise<{
+        NFe: import("src/core/types").LayoutNFe;
+        protNFe: import("src/core/types").ProtNFe;
+    }[]>;
+    NFCE_Autorizacao(data: NFe): Promise<{
+        NFe: import("src/core/types").LayoutNFe;
+        protNFe: import("src/core/types").ProtNFe;
+    }[]>;
+    /**
+     * Inutilização
+     */
+    NFE_Inutilizacao(data: InutilizacaoData): Promise<any>;
+    /**
+     * DANFE
+     */
+    NFE_GerarDanfe(data: NFEGerarDanfeProps): Promise<{
+        message: string;
+        success: boolean;
+    }>;
+    NFCE_GerarDanfe(data: NFEGerarDanfeProps): Promise<{
+        message: string;
+        success: boolean;
+    }>;
+    /**
+     * Método para envio de e-mail
+     * @param {EmailParams} mailParams - Mensagem de texto (aceita html)
+     */
+    NFE_EnviaEmail(mailParams: EmailParams): void;
+}

package/dist/esm/adapters/SchemaLoader.d.ts

@@ -0,0 +1,4 @@
+export declare const getSchema: (metodo: string) => {
+    basePath: string;
+    schemaPath: string;
+};

package/dist/esm/adapters/XmlBuilder.d.ts

@@ -0,0 +1,31 @@
+import Environment from '@Modules/environment/Environment.js';
+export interface NamespacesProps {
+    [key: string]: string;
+}
+export interface BodyContentProps {
+    [key: string]: any;
+}
+export interface SoapEnvelopeObjProps {
+    [key: string]: any;
+}
+declare class XmlBuilder {
+    environment: Environment;
+    constructor(environment: Environment);
+    /**
+     * Método para assinar o XML
+     */
+    assinarXML(xml: string, tagAssinar: string): string;
+    /**
+     * Método que converte Objeto em XML
+     */
+    serializeXml<T>(obj: T, rootTag: string): string;
+    /**
+     * Método genérico para geração do XML
+     */
+    gerarXml<T>(xmlObject: T, rootTag: string): string;
+    /**
+     *  Método utilizado para cirar um envelop SOAP - Formato de mensagem para serviço SOAP (como o da SEFAZ)
+     */
+    buildSoapEnvelope(xml: string, soapMethod: string, soapVersion?: string, rootTagObj?: any): string;
+}
+export default XmlBuilder;

package/dist/esm/core/interfaces/GerarConsultaImpl.d.ts

@@ -0,0 +1,9 @@
+import { Agent } from 'http';
+export interface GerarConsultaImpl {
+    gerarConsulta(xmlConsulta: string, metodo: string, ambienteNacional?: boolean, versao?: string, mod?: string, rootTag?: boolean, tag?: string): Promise<{
+        xmlFormated: string;
+        agent: Agent;
+        webServiceUrl: string;
+        action: string;
+    }>;
+}

package/dist/esm/core/interfaces/HttpClient.d.ts

@@ -0,0 +1,9 @@
+import https from 'https';
+export interface HttpClient<T = any> {
+    create(config: HttpClientConfig): T;
+}
+export interface HttpClientConfig {
+    headers: Record<string, string>;
+    timeout: number;
+    agent?: https.Agent;
+}

package/dist/esm/core/interfaces/NFCEAutorizacaoServiceImpl.d.ts

@@ -0,0 +1,11 @@
+import { LayoutNFe, NFe, ProtNFe, GenericObject } from '@Types';
+export interface NFCEAutorizacaoServiceImpl {
+    Exec(data: NFe): Promise<{
+        success: boolean;
+        xMotivo: GenericObject;
+        xmls: {
+            NFe: LayoutNFe;
+            protNFe: ProtNFe;
+        }[];
+    }>;
+}

package/dist/esm/core/interfaces/NFCERetornoAutorizacaoServiceImpl.d.ts

@@ -0,0 +1,13 @@
+import { ProtNFe } from '@Types';
+export interface NFCERetornoAutorizacaoServiceImpl {
+    getXmlRetorno({ tipoEmissao, nRec, protNFe, xmlNFe }: {
+        tipoEmissao: number;
+        nRec?: string;
+        protNFe?: ProtNFe[];
+        xmlNFe: string[];
+    }): Promise<{
+        success: boolean;
+        message: any;
+        data: string[];
+    }>;
+}

package/dist/esm/core/interfaces/NFEAutorizacaoServiceImpl.d.ts

@@ -0,0 +1,11 @@
+import { LayoutNFe, NFe, ProtNFe, GenericObject } from '@Types';
+export interface NFEAutorizacaoServiceImpl {
+    Exec(data: NFe): Promise<{
+        success: boolean;
+        xMotivo: GenericObject;
+        xmls: {
+            NFe: LayoutNFe;
+            protNFe: ProtNFe;
+        }[];
+    }>;
+}

package/dist/esm/core/interfaces/NFEDistribuicaoDFeServiceImpl.d.ts

@@ -0,0 +1,9 @@
+import { ConsultaNFe } from '@Types/NFEDistribuicaoDFe';
+import { GenericObject } from '@Types/Utils';
+export interface NFEDistribuicaoDFeServiceImpl {
+    Exec(data: ConsultaNFe): Promise<{
+        data: GenericObject;
+        xMotivo: any;
+        filesList: string[];
+    }>;
+}

package/dist/esm/core/interfaces/NFEInutilizacaoServiceImpl.d.ts

@@ -0,0 +1,3 @@
+export interface NFEInutilizacaoServiceImpl {
+    Exec(data?: any): Promise<any>;
+}

package/dist/esm/core/interfaces/NFERecepcaoEventoServiceImpl.d.ts

@@ -0,0 +1,9 @@
+import { EventoNFe } from '@Types/NFERecepcaoEvento';
+import { GenericObject } from '@Types/Utils';
+export interface NFERecepcaoEventoServiceImpl {
+    Exec(data: EventoNFe): Promise<{
+        success: boolean;
+        xMotivos: any[];
+        response: GenericObject[];
+    }>;
+}

package/dist/esm/core/interfaces/NFERetornoAutorizacaoServiceImpl.d.ts

@@ -0,0 +1,13 @@
+import { ProtNFe } from '@Types';
+export interface NFERetornoAutorizacaoServiceImpl {
+    getXmlRetorno({ tipoEmissao, nRec, protNFe, xmlNFe }: {
+        tipoEmissao: number;
+        nRec?: string;
+        protNFe?: ProtNFe[];
+        xmlNFe: string[];
+    }): Promise<{
+        success: boolean;
+        message: any;
+        data: string[];
+    }>;
+}

package/dist/esm/core/interfaces/NFEStatusServicoServiceImpl.d.ts

@@ -0,0 +1,3 @@
+export interface NFEStatusServicoServiceImpl {
+    Exec(data?: any): Promise<any>;
+}

package/dist/esm/core/interfaces/NFEconsultaProtocoloServiceImpl.d.ts

@@ -0,0 +1,3 @@
+export interface NFEconsultaProtocoloServiceImpl {
+    Exec(data?: any): Promise<any>;
+}

package/dist/esm/core/interfaces/NFeWizardImpl.d.ts

@@ -0,0 +1,38 @@
+import { Cancelamento, CartaDeCorrecao, CienciaDaOperacao, ConfirmacaoDaOperacao, ConsultaNFe, DesconhecimentoDaOperacao, DFePorChaveNFe, DFePorNSU, DFePorUltimoNSU, EmailParams, EPEC, EventoNFe, GenericObject, InutilizacaoData, LayoutNFe, NFe, NFEGerarDanfeProps, NFeWizardProps, OperacaoNaoRealizada, ProtNFe } from '@Types';
+export interface NFeWizardImpl {
+    NFE_LoadEnvironment({ config }: {
+        config: NFeWizardProps;
+    }): Promise<void>;
+    NFE_ConsultaStatusServico(): Promise<any>;
+    NFE_ConsultaProtocolo(chave: string): Promise<any>;
+    NFE_RecepcaoEvento(evento: EventoNFe): Promise<GenericObject[]>;
+    NFE_EventoPrevioDeEmissaoEmContingencia(evento: EPEC): Promise<GenericObject[]>;
+    NFE_Cancelamento(evento: Cancelamento): Promise<GenericObject[]>;
+    NFE_CienciaDaOperacao(evento: CienciaDaOperacao): Promise<GenericObject[]>;
+    NFE_ConfirmacaoDaOperacao(evento: ConfirmacaoDaOperacao): Promise<GenericObject[]>;
+    NFE_OperacaoNaoRealizada(evento: OperacaoNaoRealizada): Promise<GenericObject[]>;
+    NFE_CartaDeCorrecao(evento: CartaDeCorrecao): Promise<GenericObject[]>;
+    NFE_DesconhecimentoDaOperacao(evento: DesconhecimentoDaOperacao): Promise<GenericObject[]>;
+    NFE_DistribuicaoDFe(data: ConsultaNFe): Promise<GenericObject>;
+    NFE_DistribuicaoDFePorUltNSU(data: DFePorUltimoNSU): Promise<GenericObject>;
+    NFE_DistribuicaoDFePorNSU(data: DFePorNSU): Promise<GenericObject>;
+    NFE_DistribuicaoDFePorChave(data: DFePorChaveNFe): Promise<GenericObject>;
+    NFE_Autorizacao(data: NFe): Promise<{
+        NFe: LayoutNFe;
+        protNFe: ProtNFe;
+    }[]>;
+    NFCE_Autorizacao(data: NFe): Promise<{
+        NFe: LayoutNFe;
+        protNFe: ProtNFe;
+    }[]>;
+    NFE_Inutilizacao(data: InutilizacaoData): Promise<any>;
+    NFE_GerarDanfe(data: NFEGerarDanfeProps): Promise<{
+        message: string;
+        success: boolean;
+    }>;
+    NFCE_GerarDanfe(data: NFEGerarDanfeProps): Promise<{
+        message: string;
+        success: boolean;
+    }>;
+    NFE_EnviaEmail(mailParams: EmailParams): void;
+}

package/dist/esm/core/interfaces/NFeWizardServiceImpl.d.ts

@@ -0,0 +1,38 @@
+import { Cancelamento, CartaDeCorrecao, CienciaDaOperacao, ConfirmacaoDaOperacao, ConsultaNFe, DesconhecimentoDaOperacao, DFePorChaveNFe, DFePorNSU, DFePorUltimoNSU, EmailParams, EPEC, EventoNFe, GenericObject, InutilizacaoData, LayoutNFe, NFe, NFEGerarDanfeProps, NFeWizardProps, OperacaoNaoRealizada, ProtNFe } from '@Types';
+export interface NFeWizardServiceImpl {
+    NFE_LoadEnvironment({ config }: {
+        config: NFeWizardProps;
+    }): Promise<void>;
+    NFE_ConsultaStatusServico(): Promise<any>;
+    NFE_ConsultaProtocolo(chave: string): Promise<any>;
+    NFE_RecepcaoEvento(evento: EventoNFe): Promise<GenericObject[]>;
+    NFE_EventoPrevioDeEmissaoEmContingencia(evento: EPEC): Promise<GenericObject[]>;
+    NFE_Cancelamento(evento: Cancelamento): Promise<GenericObject[]>;
+    NFE_CienciaDaOperacao(evento: CienciaDaOperacao): Promise<GenericObject[]>;
+    NFE_ConfirmacaoDaOperacao(evento: ConfirmacaoDaOperacao): Promise<GenericObject[]>;
+    NFE_OperacaoNaoRealizada(evento: OperacaoNaoRealizada): Promise<GenericObject[]>;
+    NFE_CartaDeCorrecao(evento: CartaDeCorrecao): Promise<GenericObject[]>;
+    NFE_DesconhecimentoDaOperacao(evento: DesconhecimentoDaOperacao): Promise<GenericObject[]>;
+    NFE_DistribuicaoDFe(data: ConsultaNFe): Promise<GenericObject>;
+    NFE_DistribuicaoDFePorUltNSU(data: DFePorUltimoNSU): Promise<GenericObject>;
+    NFE_DistribuicaoDFePorNSU(data: DFePorNSU): Promise<GenericObject>;
+    NFE_DistribuicaoDFePorChave(data: DFePorChaveNFe): Promise<GenericObject>;
+    NFE_Autorizacao(data: NFe): Promise<{
+        NFe: LayoutNFe;
+        protNFe: ProtNFe;
+    }[]>;
+    NFCE_Autorizacao(data: NFe): Promise<{
+        NFe: LayoutNFe;
+        protNFe: ProtNFe;
+    }[]>;
+    NFE_Inutilizacao(data: InutilizacaoData): Promise<any>;
+    NFE_GerarDanfe(data: NFEGerarDanfeProps): Promise<{
+        message: string;
+        success: boolean;
+    }>;
+    NFCE_GerarDanfe(data: NFEGerarDanfeProps): Promise<{
+        message: string;
+        success: boolean;
+    }>;
+    NFE_EnviaEmail(mailParams: EmailParams): void;
+}

package/dist/esm/core/interfaces/SaveFilesImpl.d.ts

@@ -0,0 +1,5 @@
+import { GenericObject } from '@Types/Utils';
+import { AxiosResponse } from 'axios';
+export interface SaveFilesImpl {
+    salvaArquivos(xmlConsulta: string, responseInJson: GenericObject, xmlRetorno: AxiosResponse<any, any>, metodo: string, options?: Record<string, any>): void;
+}

package/dist/esm/core/interfaces/index.d.ts

@@ -0,0 +1,14 @@
+export * from './NFeWizardImpl';
+export * from './NFEAutorizacaoServiceImpl';
+export * from './SaveFilesImpl';
+export * from './GerarConsultaImpl';
+export * from './NFEStatusServicoServiceImpl';
+export * from './NFeWizardServiceImpl';
+export * from './NFEconsultaProtocoloServiceImpl';
+export * from './NFERecepcaoEventoServiceImpl';
+export * from './HttpClient';
+export * from './NFEDistribuicaoDFeServiceImpl';
+export * from './NFEInutilizacaoServiceImpl';
+export * from './NFERetornoAutorizacaoServiceImpl';
+export * from './NFCEAutorizacaoServiceImpl';
+export * from './NFCERetornoAutorizacaoServiceImpl';

package/dist/esm/core/types/EmailConfig.d.ts

@@ -0,0 +1,65 @@
+export type EmailConfig = {
+    /**
+     * @param {string} host - Host SMTP do seu provedor de e-mail
+     */
+    host: string;
+    /**
+     * @param {number} port - Porta do servidor SMTP
+     */
+    port: number;
+    /**
+     * @param {boolean} secure - true para SSL, false para outros
+     */
+    secure: boolean;
+    /**
+     * @param auth - Dados para autenticação no servidor SMTP
+     */
+    auth: {
+        /**
+         * @param {string} user - Seu e-mail para autenticação no servidor SMTP
+         */
+        user: string;
+        /**
+         * @param {string} pass -  Sua senha para autenticação no servidor SMTP
+         */
+        pass: string;
+    };
+    /**
+     * @param emailParams -  Dados para enviao do e-mail
+     */
+    emailParams: {
+        /**
+         * @param {string} from -  Remetente padrão
+         */
+        from: string;
+        /**
+         * @param {string} to -  Destinatário padrão
+         */
+        to: string;
+    };
+};
+interface Attachment {
+    /**
+     * @param {string | false} filename -  Nome do arquivo à anexar (Ex: danfe.pdf)
+     */
+    filename?: string | false;
+    /**
+     * @param {string} path -  Caminho completo para o arquivo (Ex: ./src/assets/danfe.pdf)
+     */
+    path: string;
+}
+export type EmailParams = {
+    /**
+     * @param message -  Mensagem de texto (aceita html)
+     */
+    message: string;
+    /**
+     * @param {string} subject -  Assunto do email
+     */
+    subject: string;
+    /**
+     * @param {Attachment[] | undefined} attachments -  Anexos do email
+     */
+    attachments?: Attachment[];
+};
+export {};

package/dist/esm/core/types/LoadCertificate.d.ts

@@ -0,0 +1,11 @@
+import https from 'https';
+export type CertificateLoadResult = {
+    success: boolean;
+    agent: https.Agent;
+    message: string;
+};
+export type CertificateLoadReturn = {
+    certificate: string;
+    cert_key: string;
+    agent: https.Agent;
+};