foxnfe 1.3.0

package/README.md

@@ -0,0 +1,236 @@
+# foxnfe
+
+SDK oficial FOX NF-e para Node.js — emissão NF-e, NFSe, cancelamento, consulta e integração MCP.
+
+## Requisitos
+
+- Node.js 18+
+- TypeScript 5+ (opcional, para tipagem completa)
+
+## Instalação
+
+```bash
+npm install foxnfe
+# ou
+yarn add foxnfe
+# ou
+pnpm add foxnfe
+```
+
+## Quick Start
+
+```typescript
+import { Client } from 'foxnfe';
+
+const client = new Client({ tenantSlug: 'minha-empresa' });
+
+// Autenticar
+const auth = await client.login('email@empresa.com', 'senha-segura');
+console.log('Token:', auth.token);
+
+// Ou usar token existente
+const client2 = new Client({ tenantSlug: 'minha-empresa', token: 'seu-token-aqui' });
+// Ou via withToken (retorna nova instância)
+const authed = client.withToken('seu-token-aqui');
+```
+
+## NF-e
+
+```typescript
+import { Client, NfeEmitRequest } from 'foxnfe';
+
+const client = new Client({ tenantSlug: 'minha-empresa', token: 'seu-token' });
+const nfe = new Nfe(client);
+
+// Emitir NF-e
+const payload: NfeEmitRequest = {
+    ambiente: 2, // 2=homologação
+    certificate_id: 1,
+    tomador: {
+        cnpj: '12345678000190',
+        razao_social: 'Empresa Tomadora Ltda',
+        endereco: {
+            logradouro: 'Rua das Flores',
+            numero: '100',
+            municipio: 'São Paulo',
+            uf: 'SP',
+            cep: '01310100',
+        },
+    },
+    itens: [{
+        codigo: 'SRV001',
+        descricao: 'Serviço de consultoria',
+        cfop: '5933',
+        quantidade: 1,
+        valor_unitario: 1000.00,
+        valor_total: 1000.00,
+    }],
+    pagamentos: [{ forma: '01', valor: 1000.00 }],
+    total: 1000.00,
+};
+
+const result = await nfe.emit(payload);
+console.log('NF-e ID:', result.id);
+
+// Aguardar autorização (polling automático)
+const nfeAutorizada = await nfe.waitForAuthorization(result.id);
+console.log('Status:', nfeAutorizada.status); // 'authorized'
+
+// Baixar XML
+const xml = await nfe.xml(result.id);
+await fs.writeFile('nfe.xml', xml);
+
+// Baixar DANFE PDF
+const pdf = await nfe.pdf(result.id);
+await fs.writeFile('danfe.pdf', pdf);
+
+// Cancelar
+await nfe.cancel(result.id, { justificativa: 'Cancelamento solicitado pelo cliente' });
+```
+
+## NFSe
+
+```typescript
+import { Client, Nfse, NfseEmitRequest } from 'foxnfe';
+
+const nfse = new Nfse(client);
+
+const payload: NfseEmitRequest = {
+    ambiente: 2,
+    certificate_id: 1,
+    prestador: {
+        cnpj: '12345678000190',
+        inscricao_municipal: '123456',
+        razao_social: 'Minha Empresa Ltda',
+        codigo_municipio: '3550308', // São Paulo (IBGE)
+    },
+    tomador: {
+        cnpj: '98765432000110',
+        nome: 'Cliente S.A.',
+    },
+    servico: {
+        codigo_tributacao_nacional: '01.01.00001',
+        descricao: 'Desenvolvimento de software',
+        data_competencia: '2026-05-01',
+        valor: 5000.00,
+        aliquota_iss: 2.0,
+    },
+};
+
+const result = await nfse.emit(payload);
+const nfseData = await nfse.get(result.id);
+console.log('Número NFSe:', nfseData.numero_nfse);
+
+// Consultar por RPS ou chave
+await nfse.consultByNumero('00000001');
+await nfse.consultByChave('SP3550308202605010000000000001');
+
+// Cancelar / Substituir
+await nfse.cancel(result.id, { motivo: 'Erro nos dados' });
+await nfse.substitute(result.id, { ...payload, motivo_cancelamento: 'Correção' });
+```
+
+## MCP (Model Context Protocol)
+
+```typescript
+import { Mcp } from 'foxnfe';
+
+const mcp = new Mcp(client);
+
+// Inicializar sessão MCP
+const info = await mcp.initialize();
+console.log('MCP Server:', info.serverInfo.name);
+
+// Listar tools
+const { tools } = await mcp.listTools();
+tools.forEach(t => console.log(`${t.name}: ${t.description}`));
+
+// Chamar uma tool
+const result = await mcp.callTool('emitir_nfe', {
+    ambiente: 2,
+    certificate_id: 1,
+    // ...
+});
+
+if (result.is_error) {
+    console.error('Tool error:', result.content[0]?.text);
+} else {
+    console.log('Tool result:', result.content[0]?.text);
+}
+```
+
+## 1.3.0 — eventos, rejeições, homologação, RTC, cobertura NFS-e e suporte
+
+```typescript
+import { NfeEvents, Nfe, Nfse, Rtc, Support } from 'foxnfe';
+
+const ev = new NfeEvents(client);
+await ev.atorInteressado(15, { documento: '11222333000181' });          // 110150
+await ev.insucessoEntrega(15, { dh_tentativa: '2026-09-08T10:00:00-03:00', tp_motivo: 1 }); // 110192
+await ev.inutilizar({ serie: 1, numero_inicial: 10, numero_final: 12, justificativa: 'Numeração pulada por falha do ERP' });
+await ev.contratos();                                                  // catálogo (conciliação financeira, RTC…)
+await ev.registrarEvento(15, 'econf', { /* campos do contrato */ });
+
+const nfe = new Nfe(client);
+await nfe.rejeicao('539');                                             // categoria/ação/dica
+await nfe.homologacaoRun(65);                                          // amostras XML/PDF simuladas por cenário
+
+await new Nfse(client).coberturaMunicipio('2304400');                  // driver, operações e provas
+const rtc = new Rtc(client);
+await rtc.verifyResolution('550e8400-e29b-41d4-a716-446655440000');   // reproducible | output_drift | version_drift
+await new Support(client).createCase({ subject: 'Webhook sem entrega desde ontem', priority: 'high' });
+```
+
+Cada método valida localmente o que pode (ids, dígitos, tamanhos, enums) e deixa a regra fiscal para a API. A consulta de NF-e traz `rejection` quando houver rejeição SEFAZ.
+
+## Tratamento de Erros
+
+```typescript
+import { ApiException, AuthException, FoxNfeException } from 'foxnfe';
+
+try {
+    await nfe.emit(payload);
+} catch (err) {
+    if (err instanceof AuthException) {
+        // Token inválido ou expirado (401/403)
+        console.error('Auth error:', err.message);
+    } else if (err instanceof ApiException) {
+        // Erro da API (422, 500, etc.)
+        console.error(`API error ${err.statusCode}:`, err.message);
+        console.error('Body:', err.responseBody);
+    } else if (err instanceof FoxNfeException) {
+        // Timeout, erro de rede, etc.
+        console.error('SDK error:', err.message);
+    }
+}
+```
+
+## Configuração avançada
+
+```typescript
+const client = new Client({
+    tenantSlug: 'minha-empresa',
+    token:      'seu-token',
+    baseUrl:    'https://sandbox.centralfox.online/api/v1',
+    timeoutMs:  60_000,
+});
+```
+
+## Estrutura do pacote
+
+```
+src/
+├── index.ts      # Exports públicos + createClient()
+├── client.ts     # Cliente HTTP principal
+├── nfe.ts        # Módulo NF-e
+├── nfse.ts       # Módulo NFSe
+├── mcp.ts        # Módulo MCP
+├── types.ts      # Tipos TypeScript exportados
+└── errors.ts     # Classes de erro
+```
+
+## Links
+
+- [Documentação API](https://docs.centralfox.online)
+- [Portal FOX NF-e](https://foxnfe.centralfox.online)
+- [Suporte](mailto:suporte@centralfox.online)

package/dist/client.d.ts

@@ -0,0 +1,34 @@
+import { ClientOptions, LoginResponse } from './types.js';
+export declare class Client {
+    private static readonly DEFAULT_BASE_URL;
+    readonly tenantSlug: string;
+    private token?;
+    private readonly baseUrl;
+    private readonly timeoutMs;
+    constructor(options: ClientOptions);
+    /** Autentica e armazena o token internamente. */
+    login(email: string, password: string): Promise<LoginResponse>;
+    /** Retorna uma nova instância com o token definido. */
+    withToken(token: string): Client;
+    logout(): Promise<void>;
+    me(): Promise<Record<string, unknown>>;
+    get<T = Record<string, unknown>>(path: string, params?: Record<string, string>): Promise<T>;
+    post<T = Record<string, unknown>>(path: string, body?: unknown): Promise<T>;
+    put<T = Record<string, unknown>>(path: string, body?: unknown): Promise<T>;
+    delete<T = Record<string, unknown>>(path: string): Promise<T>;
+    /** Retorna Buffer com conteúdo binário (XML, PDF). */
+    download(path: string): Promise<Buffer>;
+    private buildUrl;
+    /**
+     * Envio multipart (upload de XML). O Content-Type é definido pelo runtime com o
+     * boundary; nunca use JSON aqui.
+     */
+    upload<T = Record<string, unknown>>(path: string, file: {
+        field: string;
+        filename: string;
+        content: Buffer | string;
+        contentType?: string;
+    }, fields?: Record<string, string>): Promise<T>;
+    private fetch;
+    private parseJson;
+}

package/dist/client.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+const errors_js_1 = require("./errors.js");
+class Client {
+    constructor(options) {
+        this.tenantSlug = options.tenantSlug;
+        this.token = options.token;
+        this.baseUrl = options.baseUrl?.replace(/\/$/, '') ?? Client.DEFAULT_BASE_URL;
+        this.timeoutMs = options.timeoutMs ?? 30000;
+    }
+    /** Autentica e armazena o token internamente. */
+    async login(email, password) {
+        const data = await this.post('auth/login', { email, password });
+        if (!data.token)
+            throw new errors_js_1.AuthException('Token não retornado pela API.');
+        this.token = data.token;
+        return data;
+    }
+    /** Retorna uma nova instância com o token definido. */
+    withToken(token) {
+        return new Client({
+            tenantSlug: this.tenantSlug,
+            baseUrl: this.baseUrl,
+            timeoutMs: this.timeoutMs,
+            token,
+        });
+    }
+    async logout() {
+        await this.post('auth/logout');
+        this.token = undefined;
+    }
+    async me() {
+        return this.get('auth/me');
+    }
+    // ── HTTP helpers ────────────────────────────────────────────────────────
+    async get(path, params) {
+        const url = this.buildUrl(path, params);
+        const res = await this.fetch(url, { method: 'GET' });
+        return this.parseJson(res);
+    }
+    async post(path, body) {
+        const url = this.buildUrl(path);
+        const res = await this.fetch(url, {
+            method: 'POST',
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+        });
+        return this.parseJson(res);
+    }
+    async put(path, body) {
+        const url = this.buildUrl(path);
+        const res = await this.fetch(url, {
+            method: 'PUT',
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+        });
+        return this.parseJson(res);
+    }
+    async delete(path) {
+        const url = this.buildUrl(path);
+        const res = await this.fetch(url, { method: 'DELETE' });
+        return this.parseJson(res);
+    }
+    /** Retorna Buffer com conteúdo binário (XML, PDF). */
+    async download(path) {
+        const url = this.buildUrl(path);
+        const res = await this.fetch(url, { method: 'GET' });
+        if (!res.ok) {
+            const body = await res.json().catch(() => ({}));
+            throw errors_js_1.ApiException.fromResponse(res.status, body);
+        }
+        return Buffer.from(await res.arrayBuffer());
+    }
+    buildUrl(path, params) {
+        const url = new URL(`${this.baseUrl}/${path}`);
+        if (params) {
+            Object.entries(params).forEach(([k, v]) => url.searchParams.set(k, v));
+        }
+        return url.toString();
+    }
+    /**
+     * Envio multipart (upload de XML). O Content-Type é definido pelo runtime com o
+     * boundary; nunca use JSON aqui.
+     */
+    async upload(path, file, fields = {}) {
+        const form = new FormData();
+        for (const [k, v] of Object.entries(fields))
+            form.set(k, v);
+        form.set(file.field, new Blob([file.content], { type: file.contentType ?? 'application/xml' }), file.filename);
+        const res = await this.fetch(this.buildUrl(path), { method: 'POST', body: form }, null);
+        return this.parseJson(res);
+    }
+    async fetch(url, init, contentType = 'application/json') {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        try {
+            return await fetch(url, {
+                ...init,
+                signal: controller.signal,
+                headers: {
+                    ...(contentType ? { 'Content-Type': contentType } : {}),
+                    'Accept': 'application/json',
+                    'X-Tenant-ID': this.tenantSlug,
+                    ...(this.token ? { Authorization: `Bearer ${this.token}` } : {}),
+                },
+            });
+        }
+        catch (err) {
+            if (err?.name === 'AbortError') {
+                throw new errors_js_1.FoxNfeException(`Timeout após ${this.timeoutMs}ms`);
+            }
+            throw new errors_js_1.FoxNfeException(`Erro de rede: ${err?.message ?? err}`);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async parseJson(res) {
+        let body;
+        try {
+            body = await res.json();
+        }
+        catch {
+            throw new errors_js_1.FoxNfeException('Resposta JSON inválida.');
+        }
+        if (!res.ok) {
+            const err = body;
+            if (res.status === 401 || res.status === 403) {
+                throw new errors_js_1.AuthException(err.message ?? 'Não autorizado.');
+            }
+            throw errors_js_1.ApiException.fromResponse(res.status, err);
+        }
+        return body;
+    }
+}
+exports.Client = Client;
+Client.DEFAULT_BASE_URL = 'https://foxnfe.centralfox.online/api/v1';

package/dist/distribuicao.d.ts

@@ -0,0 +1,38 @@
+import { Client } from './client.js';
+export interface ManifestacaoRequest {
+    chave_acesso: string;
+    tipo_evento: 210200 | 210210 | 210220 | 210240;
+    n_seq_evento?: number;
+    justificativa?: string;
+    nfe_distribuicao_id?: number;
+    certificate_id?: number;
+    ambiente?: 1 | 2;
+}
+/**
+ * NF-e recebidas (capacidade 10): distribuição DF-e, cursor NSU, captura
+ * automática (opt-in) e manifestação do destinatário (solicitar → aprovar →
+ * transmitir; `reconciliar` resolve uma transmissão ambígua por consulta real).
+ */
+export declare class Distribuicao {
+    private readonly client;
+    constructor(client: Client);
+    list(params?: Record<string, string | number | undefined>): Promise<Record<string, unknown>>;
+    cursor(): Promise<Record<string, unknown>>;
+    optins(): Promise<Record<string, unknown>>;
+    enableOptin(certificateId: number, ambiente: 1 | 2): Promise<Record<string, unknown>>;
+    disableOptin(id: number): Promise<Record<string, unknown>>;
+    /** Captura manual (bounded); `certificate_id`/`ambiente` opcionais. */
+    capturar(params?: {
+        certificate_id?: number;
+        ambiente?: 1 | 2;
+    }): Promise<Record<string, unknown>>;
+    manifestacoes(params?: Record<string, string | number | undefined>): Promise<Record<string, unknown>>;
+    manifestacao(id: number): Promise<Record<string, unknown>>;
+    solicitarManifestacao(body: ManifestacaoRequest): Promise<Record<string, unknown>>;
+    /** Aprovação vinculada ao payload_hash devolvido na solicitação (alteração invalida). */
+    aprovarManifestacao(id: number, payloadHash: string): Promise<Record<string, unknown>>;
+    transmitirManifestacao(id: number): Promise<Record<string, unknown>>;
+    reconciliarManifestacao(id: number): Promise<Record<string, unknown>>;
+    private static q;
+    private static id;
+}

package/dist/distribuicao.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Distribuicao = void 0;
+/**
+ * NF-e recebidas (capacidade 10): distribuição DF-e, cursor NSU, captura
+ * automática (opt-in) e manifestação do destinatário (solicitar → aprovar →
+ * transmitir; `reconciliar` resolve uma transmissão ambígua por consulta real).
+ */
+class Distribuicao {
+    constructor(client) {
+        this.client = client;
+    }
+    list(params = {}) { return this.client.get('nfe-distribuicao', Distribuicao.q(params)); }
+    cursor() { return this.client.get('nfe-distribuicao/cursor'); }
+    optins() { return this.client.get('nfe-distribuicao/captura-automatica'); }
+    enableOptin(certificateId, ambiente) {
+        Distribuicao.id(certificateId, 'certificateId');
+        return this.client.put('nfe-distribuicao/captura-automatica', { certificate_id: certificateId, ambiente });
+    }
+    disableOptin(id) { Distribuicao.id(id, 'id'); return this.client.delete(`nfe-distribuicao/captura-automatica/${id}`); }
+    /** Captura manual (bounded); `certificate_id`/`ambiente` opcionais. */
+    capturar(params = {}) { return this.client.post('nfe-distribuicao/capturar', params); }
+    manifestacoes(params = {}) { return this.client.get('nfe-distribuicao/manifestacoes', Distribuicao.q(params)); }
+    manifestacao(id) { Distribuicao.id(id, 'id'); return this.client.get(`nfe-distribuicao/manifestacoes/${id}`); }
+    solicitarManifestacao(body) {
+        if (!/^[0-9]{6}[0-9A-Z]{12}[0-9]{26}$/.test(body.chave_acesso))
+            throw new TypeError('chave_acesso inválida (44 posições).');
+        if (![210200, 210210, 210220, 210240].includes(body.tipo_evento))
+            throw new TypeError('tipo_evento inválido.');
+        return this.client.post('nfe-distribuicao/manifestacoes', body);
+    }
+    /** Aprovação vinculada ao payload_hash devolvido na solicitação (alteração invalida). */
+    aprovarManifestacao(id, payloadHash) {
+        Distribuicao.id(id, 'id');
+        if (!/^[0-9a-f]{64}$/.test(payloadHash))
+            throw new TypeError('payloadHash deve ser sha256 hex minúsculo.');
+        return this.client.post(`nfe-distribuicao/manifestacoes/${id}/aprovar`, { payload_hash: payloadHash });
+    }
+    transmitirManifestacao(id) { Distribuicao.id(id, 'id'); return this.client.post(`nfe-distribuicao/manifestacoes/${id}/transmitir`); }
+    reconciliarManifestacao(id) { Distribuicao.id(id, 'id'); return this.client.post(`nfe-distribuicao/manifestacoes/${id}/reconciliar`); }
+    static q(params) {
+        const p = {};
+        for (const [k, v] of Object.entries(params))
+            if (v !== undefined)
+                p[k] = String(v);
+        return p;
+    }
+    static id(id, label) {
+        if (!Number.isInteger(id) || id < 1)
+            throw new TypeError(`${label} deve ser inteiro positivo.`);
+    }
+}
+exports.Distribuicao = Distribuicao;

package/dist/documents.d.ts

@@ -0,0 +1,28 @@
+import { Client } from './client.js';
+export interface DocumentListParams {
+    [key: string]: string | number | undefined;
+}
+/**
+ * Central de Documentos (capacidades 14/15/16): consulta unificada (emitidas,
+ * recebidas, importadas), detalhe, importação de XML de terceiros com prévia
+ * (sem valor fiscal próprio) e exportação ZIP assíncrona.
+ */
+export declare class Documents {
+    private readonly client;
+    constructor(client: Client);
+    /** Consulta unificada paginada (filtros: período, origem, tipo, status, participante…). */
+    list(params?: DocumentListParams): Promise<Record<string, unknown>>;
+    /** Detalhe por origem (`nfes`, `nfses`, `nfe_distribuicoes`, `imported_documents`) e id. */
+    show(source: string, id: number): Promise<Record<string, unknown>>;
+    /** Prévia de importação: valida e vincula SEM persistir; devolve integrity.raw_sha256 para o commit. */
+    importPreview(xml: Buffer | string, filename?: string): Promise<Record<string, unknown>>;
+    /** Importa o XML (mesmos bytes da prévia quando previewSha256 é informado). */
+    import(xml: Buffer | string, previewSha256?: string, filename?: string): Promise<Record<string, unknown>>;
+    /** Solicita exportação ZIP assíncrona com os mesmos filtros da consulta. */
+    exportRequest(filters?: DocumentListParams): Promise<Record<string, unknown>>;
+    exportStatus(requestId: string): Promise<Record<string, unknown>>;
+    /** ZIP com manifesto de hashes; confira a integridade antes de arquivar. */
+    exportDownload(requestId: string): Promise<Buffer>;
+    private static id;
+    private static uuid;
+}

package/dist/documents.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Documents = void 0;
+/**
+ * Central de Documentos (capacidades 14/15/16): consulta unificada (emitidas,
+ * recebidas, importadas), detalhe, importação de XML de terceiros com prévia
+ * (sem valor fiscal próprio) e exportação ZIP assíncrona.
+ */
+class Documents {
+    constructor(client) {
+        this.client = client;
+    }
+    /** Consulta unificada paginada (filtros: período, origem, tipo, status, participante…). */
+    list(params = {}) {
+        const p = {};
+        for (const [k, v] of Object.entries(params))
+            if (v !== undefined)
+                p[k] = String(v);
+        return this.client.get('documents', p);
+    }
+    /** Detalhe por origem (`nfes`, `nfses`, `nfe_distribuicoes`, `imported_documents`) e id. */
+    show(source, id) {
+        if (!/^[a-z_]+$/.test(source))
+            throw new TypeError('source inválido.');
+        Documents.id(id);
+        return this.client.get(`documents/${source}/${id}`);
+    }
+    /** Prévia de importação: valida e vincula SEM persistir; devolve integrity.raw_sha256 para o commit. */
+    importPreview(xml, filename = 'nota.xml') {
+        return this.client.upload('documents/imports/preview', { field: 'file', filename, content: xml });
+    }
+    /** Importa o XML (mesmos bytes da prévia quando previewSha256 é informado). */
+    import(xml, previewSha256, filename = 'nota.xml') {
+        const fields = {};
+        if (previewSha256 !== undefined) {
+            if (!/^[0-9a-f]{64}$/.test(previewSha256))
+                throw new TypeError('previewSha256 deve ser sha256 hex minúsculo.');
+            fields.preview_sha256 = previewSha256;
+        }
+        return this.client.upload('documents/imports', { field: 'file', filename, content: xml }, fields);
+    }
+    /** Solicita exportação ZIP assíncrona com os mesmos filtros da consulta. */
+    exportRequest(filters = {}) {
+        return this.client.post('documents/exports', filters);
+    }
+    exportStatus(requestId) {
+        Documents.uuid(requestId);
+        return this.client.get(`documents/exports/${requestId}`);
+    }
+    /** ZIP com manifesto de hashes; confira a integridade antes de arquivar. */
+    exportDownload(requestId) {
+        Documents.uuid(requestId);
+        return this.client.download(`documents/exports/${requestId}/download`);
+    }
+    static id(id) {
+        if (!Number.isInteger(id) || id < 1)
+            throw new TypeError('id deve ser inteiro positivo.');
+    }
+    static uuid(v) {
+        if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(v))
+            throw new TypeError('requestId deve ser um UUID válido.');
+    }
+}
+exports.Documents = Documents;

package/dist/errors.d.ts

@@ -0,0 +1,14 @@
+import { ApiErrorResponse } from './types.js';
+export declare class FoxNfeException extends Error {
+    readonly context?: unknown | undefined;
+    constructor(message: string, context?: unknown | undefined);
+}
+export declare class ApiException extends FoxNfeException {
+    readonly statusCode: number;
+    readonly responseBody?: ApiErrorResponse | undefined;
+    constructor(statusCode: number, message: string, responseBody?: ApiErrorResponse | undefined);
+    static fromResponse(statusCode: number, body: ApiErrorResponse): ApiException;
+}
+export declare class AuthException extends FoxNfeException {
+    constructor(message: string);
+}

package/dist/errors.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthException = exports.ApiException = exports.FoxNfeException = void 0;
+class FoxNfeException extends Error {
+    constructor(message, context) {
+        super(message);
+        this.context = context;
+        this.name = 'FoxNfeException';
+    }
+}
+exports.FoxNfeException = FoxNfeException;
+class ApiException extends FoxNfeException {
+    constructor(statusCode, message, responseBody) {
+        super(message, responseBody);
+        this.statusCode = statusCode;
+        this.responseBody = responseBody;
+        this.name = 'ApiException';
+    }
+    static fromResponse(statusCode, body) {
+        return new ApiException(statusCode, body.message ?? `HTTP ${statusCode}`, body);
+    }
+}
+exports.ApiException = ApiException;
+class AuthException extends FoxNfeException {
+    constructor(message) {
+        super(message);
+        this.name = 'AuthException';
+    }
+}
+exports.AuthException = AuthException;