NFe DANFE PDF

https://www.npmjs.com/package/nfe-danfe-pdf
Admin
Uma biblioteca robusta e completa para a geração de DANFE (Documento Auxiliar da Nota Fiscal...
Tokens:9,155
Snippets:81
Trust Score:9.6
Update:1 year ago
Show doc for...
Tokens:
Raw
### Installation

Source: https://www.npmjs.com/package/nfe-danfe-pdf/index_activetab=dependencies

Instructions on how to install the nfe-danfe-pdf package using NPM, Yarn, or PNPM.

```APIDOC
## Installation

### NPM
```
npm install nfe-danfe-pdf
```

### Yarn
```
yarn add nfe-danfe-pdf
```

### PNPM
```
pnpm add nfe-danfe-pdf
```
```

--------------------------------

### Advanced Usage

Source: https://www.npmjs.com/package/nfe-danfe-pdf/index_activetab=dependencies

Example demonstrating advanced usage with custom options for generating a DANFE PDF.

```APIDOC
## Advanced Usage

### Advanced Example

```javascript
import { gerarPDF } from 'nfe-danfe-pdf';
import fs from 'fs';

const xmlContent = fs.readFileSync('./nfe.xml', 'utf8');

// Opções personalizadas
const opcoes = {
  pathLogo: './assets/logo-empresa.png', // Logo da empresa
  cancelada: false, // Nota não cancelada
  textoRodape: 'Meu Sistema Danfe' // Texto personalizado no rodapé
};

const pdfDoc = await gerarPDF(xmlContent, opcoes);

// Salvando com callback
pdfDoc.pipe(fs.createWriteStream('./danfe-personalizado.pdf'));
pdfDoc.on('end', () => {
  console.log('✅ DANFE gerado com sucesso!');
});
pdfDoc.end();
```
```

--------------------------------

### Install nfe-danfe-pdf using npm, yarn, or pnpm

Source: https://www.npmjs.com/package/nfe-danfe-pdf/index

This snippet shows how to install the nfe-danfe-pdf package using different package managers available in Node.js.

```bash
# NPM
npm install nfe-danfe-pdf

# Yarn
yarn add nfe-danfe-pdf

# PNPM
pnpm add nfe-danfe-pdf
```

--------------------------------

### Basic Usage

Source: https://www.npmjs.com/package/nfe-danfe-pdf/index_activetab=dependencies

Example demonstrating the basic usage of the `gerarPDF` function to generate a DANFE PDF from an XML file.

```APIDOC
## Basic Usage

### Simple Example

```javascript
import { gerarPDF } from 'nfe-danfe-pdf';
import fs from 'fs';

async function main() {
  try {
    // Carregando XML da NFe
    const xmlContent = fs.readFileSync('./nota-fiscal.xml', 'utf8');

    // Gerando PDF
    const pdfDoc = await gerarPDF(xmlContent);

    // Salvando arquivo
    const writeStream = fs.createWriteStream('./danfe.pdf');
    pdfDoc.pipe(writeStream);

    // Aguardar finalização do arquivo
    await new Promise<void>((resolve, reject) => {
      writeStream.on('finish', () => {
        console.log('PDF gerado com sucesso!');
        resolve();
      });

      writeStream.on('error', reject);
      pdfDoc.on('error', reject);
    });
  } catch (error) {
    console.error('Erro:', error);
  }
}

main();
```
```

--------------------------------

### Generate DANFE PDF in Next.js API Route (TypeScript)

Source: https://www.npmjs.com/package/nfe-danfe-pdf/index_activetab=code

This API route handles POST requests to generate a DANFE PDF from XML data. It uses the 'nfe-danfe-pdf' library and returns the PDF as a Buffer. Ensure the server has the necessary dependencies installed.

```typescript
import { gerarPDF } from 'nfe-danfe-pdf';
import { NextRequest, NextResponse } from 'next/server';

export async function POST(request: NextRequest) {
  try {
    const { xml, pathLogo } = await request.json();

    const pdfDoc = await gerarPDF(xml, { pathLogo });

    // Converter PDFKit document para Buffer
    const chunks: Buffer[] = [];

    return new Promise((resolve) => {
      pdfDoc.on('data', (chunk) => chunks.push(chunk));
      pdfDoc.on('end', () => {
        const pdfBuffer = Buffer.concat(chunks);

        resolve(
          new NextResponse(pdfBuffer, {
            status: 200,
            headers: {
              'Content-Type': 'application/pdf',
              'Content-Disposition': 'attachment; filename="danfe.pdf"'
            }
          })
        );
      });
      pdfDoc.end();
    });
  } catch (error) {
    return NextResponse.json({ error: 'Erro ao gerar DANFE' }, { status: 500 });
  }
}
```

--------------------------------

### NFe DANFE PDF Generation API

Source: https://www.npmjs.com/package/nfe-danfe-pdf/index_activetab=versions

This section details the primary function for generating DANFE PDFs, including its parameters, options, and usage examples.

```APIDOC
## `gerarPDF(xml, opcoes?)`

### Description
Generates a DANFE (NF-e or NFC-e) PDF document from XML content with optional customization.

### Method
`gerarPDF`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
Not applicable (function parameters are used).

### Function Signature
`gerarPDF(xml: string, opcoes?: OpcoesPDF): Promise<PDFKit.PDFDocument>`

### Parameters
- **`xml`** (string) - Required - The XML content of the NF-e or NFC-e.
- **`opcoes`** (`OpcoesPDF`) - Optional - Customization options for the PDF generation.

### Type `OpcoesPDF`
```
type OpcoesPDF = {
  pathLogo?: string; // Path to the company logo image
  cancelada?: boolean; // Mark the document as canceled
  textoRodape?: string; // Custom text for the document footer
};
```

### Parameter Details
- **`pathLogo`**: Path to the company logo image file (e.g., PNG, JPG). This logo will be displayed on the DANFE.
- **`cancelada`**: A boolean value. If set to `true`, the DANFE will be visually marked as canceled.
- **`textoRodape`**: Custom text that will appear in the right-hand side of the document footer. For example: "Meu Sistema Danfe".

### Request Example (Basic Usage)
```javascript
import { gerarPDF } from 'nfe-danfe-pdf';
import fs from 'fs';

async function main() {
  try {
    // Loading NFe XML
    const xmlContent = fs.readFileSync('./nota-fiscal.xml', 'utf8');

    // Generating PDF
    const pdfDoc = await gerarPDF(xmlContent);

    // Saving file
    const writeStream = fs.createWriteStream('./danfe.pdf');
    pdfDoc.pipe(writeStream);

    // Wait for file finalization
    await new Promise<void>((resolve, reject) => {
      writeStream.on('finish', () => {
        console.log('PDF generated successfully!');
        resolve();
      });

      writeStream.on('error', reject);
      pdfDoc.on('error', reject);
    });
  } catch (error) {
    console.error('Error:', error);
  }
}

main();
```

### Request Example (Advanced Usage with Customizations)
```javascript
import { gerarPDF } from 'nfe-danfe-pdf';
import fs from 'fs';

const xmlContent = fs.readFileSync('./nfe.xml', 'utf8');

// Custom options
const opcoes = {
  pathLogo: './assets/logo-empresa.png', // Company logo
  cancelada: false, // Document not canceled
  textoRodape: 'Meu Sistema Danfe' // Custom text in the footer
};

const pdfDoc = await gerarPDF(xmlContent, opcoes);

// Saving with callback
pdfDoc.pipe(fs.createWriteStream('./danfe-personalizado.pdf'));
pdfDoc.on('end', () => {
  console.log('✅ DANFE generated successfully!');
});
pdfDoc.end();
```

### Response
#### Success Response (Promise<PDFKit.PDFDocument>)
- The function returns a `Promise` that resolves with a `PDFKit.PDFDocument` object, which can then be piped to a file stream or manipulated further.

#### Response Example (Conceptual)
```javascript
// The returned object is a PDF document stream.
// Example of piping to a file:
pdfDoc.pipe(fs.createWriteStream('output.pdf'));
```

#### Error Response
- **`error`** (Error) - If an error occurs during PDF generation (e.g., invalid XML, file system issues), the promise will be rejected with an `Error` object.

#### Error Example
```javascript
// In the async function example:
} catch (error) {
  console.error('Error generating PDF:', error);
}
```
```

--------------------------------

### Generate DANFE PDF from XML in Node.js (Basic Usage)

Source: https://www.npmjs.com/package/nfe-danfe-pdf/index

This basic example demonstrates how to use the `gerarPDF` function to generate a DANFE PDF from an XML file and save it to the file system. It reads the XML content, generates the PDF, and pipes it to a write stream.

```javascript
import { gerarPDF } from 'nfe-danfe-pdf';
import fs from 'fs';

async function main() {
  try {
    // Carregando XML da NFe
    const xmlContent = fs.readFileSync('./nota-fiscal.xml', 'utf8');

    // Gerando PDF
    const pdfDoc = await gerarPDF(xmlContent);

    // Salvando arquivo
    const writeStream = fs.createWriteStream('./danfe.pdf');
    pdfDoc.pipe(writeStream);

    // Aguardar finalização do arquivo
    await new Promise<void>((resolve, reject) => {
      writeStream.on('finish', () => {
        console.log('PDF gerado com sucesso!');
        resolve();
      });

      writeStream.on('error', reject);
      pdfDoc.on('error', reject);
    });
  } catch (error) {
    console.error('Erro:', error);
  }
}

main();
```

--------------------------------

### Customize DANFE PDF with Footer Text in Node.js

Source: https://www.npmjs.com/package/nfe-danfe-pdf/index

This example specifically illustrates how to add a custom text to the footer of the generated DANFE PDF. It configures the `textoRodape` option within the `opcoes` object passed to the `gerarPDF` function.

```javascript
import { gerarPDF } from 'nfe-danfe-pdf';
import fs from 'fs';

const xmlContent = fs.readFileSync('./nfe.xml', 'utf8');

// Opções com texto personalizado no rodapé
const opcoes = {
  pathLogo: './assets/logo-empresa.png',
  cancelada: false,
  textoRodape: 'Meu Sistema Danfe' // Texto que aparece no canto inferior direito
};

const pdfDoc = await gerarPDF(xmlContent, opcoes);
pdfDoc.pipe(fs.createWriteStream('./danfe-com-rodape.pdf'));
```

--------------------------------

### Generate Customized DANFE PDF in Node.js (Advanced Usage)

Source: https://www.npmjs.com/package/nfe-danfe-pdf/index

This advanced example shows how to generate a DANFE PDF with custom options, such as specifying a company logo, marking the document as cancelled, and adding a custom footer text. It utilizes the `gerarPDF` function with an options object.

```javascript
import { gerarPDF } from 'nfe-danfe-pdf';
import fs from 'fs';

const xmlContent = fs.readFileSync('./nfe.xml', 'utf8');

// Opções personalizadas
const opcoes = {
  pathLogo: './assets/logo-empresa.png', // Logo da empresa
  cancelada: false, // Nota não cancelada
  textoRodape: 'Meu Sistema Danfe' // Texto personalizado no rodapé
};

const pdfDoc = await gerarPDF(xmlContent, opcoes);

// Salvando com callback
pdfDoc.pipe(fs.createWriteStream('./danfe-personalizado.pdf'));
pdfDoc.on('end', () => {
  console.log('✅ DANFE gerado com sucesso!');
});
pdfDoc.end();
```

--------------------------------

### Componente Cliente para Download de DANFE PDF em Next.js

Source: https://www.npmjs.com/package/nfe-danfe-pdf/index

Este componente React ('DanfeButton') para Next.js permite que o usuário inicie o download de um DANFE PDF. Ele faz uma requisição POST para a API de geração de DANFE, recebe o blob do PDF e o salva localmente. Inclui estados de carregamento e tratamento de erros.

```typescript
'use client';

import { useState } from 'react';

interface DanfeButtonProps {
  xmlContent: string;
  logoPath?: string;
}

export default function DanfeButton({ xmlContent, logoPath }: DanfeButtonProps) {
  const [isGenerating, setIsGenerating] = useState(false);

  const handleDownload = async () => {
    setIsGenerating(true);

    try {
      const response = await fetch('/api/gerar-danfe', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          xml: xmlContent,
          pathLogo: logoPath,
          textoRodape: 'Meu Sistema Danfe'
        })
      });
      if (!response.ok) {
        throw new Error('Erro ao gerar DANFE');
      }

      const blob = await response.blob();
      const url = URL.createObjectURL(blob);

      const link = document.createElement('a');
      link.href = url;
      link.download = 'danfe.pdf';
      link.click();

      URL.revokeObjectURL(url);
    } catch (error) {
      console.error('Erro:', error);
      alert('Erro ao gerar DANFE');
    } finally {
      setIsGenerating(false);
    }
  };

  return (
    <button
      onClick={handleDownload}
      disabled={isGenerating}
      className="px-4 py-2 bg-blue-600 text-white rounded hover:bg-blue-700 disabled:opacity-50"
    >
      {isGenerating ? 'Gerando DANFE...' : 'Download DANFE'}
    </button>
  );
}
```

--------------------------------

### Gerar DANFE PDF em API Route Next.js

Source: https://www.npmjs.com/package/nfe-danfe-pdf/index

Esta API Route em Next.js recebe um XML e um caminho de logo via POST, gera um DANFE PDF usando a biblioteca 'nfe-danfe-pdf', e retorna o PDF como resposta. Inclui tratamento de erros e configuração de headers para download.

```typescript
import { gerarPDF } from 'nfe-danfe-pdf';
import { NextRequest, NextResponse } from 'next/server';

export async function POST(request: NextRequest) {
  try {
    const { xml, pathLogo } = await request.json();

    const pdfDoc = await gerarPDF(xml, { pathLogo });

    const chunks: Buffer[] = [];

    return new Promise((resolve) => {
      pdfDoc.on('data', (chunk) => chunks.push(chunk));
      pdfDoc.on('end', () => {
        const pdfBuffer = Buffer.concat(chunks);

        resolve(
          new NextResponse(pdfBuffer, {
            status: 200,
            headers: {
              'Content-Type': 'application/pdf',
              'Content-Disposition': 'attachment; filename="danfe.pdf"'
            }
          })
        );
      });
      pdfDoc.end();
    });
  } catch (error) {
    return NextResponse.json({ error: 'Erro ao gerar DANFE' }, { status: 500 });
  }
}
```

--------------------------------

### Scripts NPM para Desenvolvimento

Source: https://www.npmjs.com/package/nfe-danfe-pdf/index

Conjunto de scripts npm para gerenciar o ciclo de desenvolvimento do projeto, incluindo compilação, testes, formatação de código e verificação de tipos. Esses scripts são essenciais para manter a qualidade e a organização do código.

```bash
npm run build     # Compilar TypeScript
npm run test      # Executar testes
npm run prettier  # Formatar código
npm run type      # Verificar tipos
```

--------------------------------

### API Documentation

Source: https://www.npmjs.com/package/nfe-danfe-pdf/index_activetab=dependencies

Detailed documentation for the `gerarPDF` function, including parameters, return type, and custom options.

```APIDOC
## API Completa

### `gerarPDF(xml, opcoes?)`

**Parâmetros:**
  * **`xml`**`string` : Conteúdo XML da NF-e/NFC-e
  * **`opcoes`**`OpcoesPDF` _(opcional)_ : Configurações personalizadas

**Retorna:** `Promise<PDFKit.PDFDocument>`

### Tipo`OpcoesPDF`

```typescript
type OpcoesPDF = {
  pathLogo?: string; // Caminho para logo da empresa
  cancelada?: boolean; // Marcar nota como cancelada
  textoRodape?: string; // Texto personalizado no rodapé do documento
};
```

#### **Detalhes dos Parâmetros:**
  * **`pathLogo`**: Caminho para arquivo de imagem da logo da empresa (PNG, JPG, etc.)
  * **`cancelada`**: Define se a nota deve ser marcada visualmente como cancelada
  * **`textoRodape`**: Texto personalizado que aparece no rodapé direito do documento (ex: "Meu Sistema Danfe")

#### **Exemplo com Rodapé Personalizado:**

```javascript
import { gerarPDF } from 'nfe-danfe-pdf';
import fs from 'fs';

const xmlContent = fs.readFileSync('./nfe.xml', 'utf8');

// Opções com texto personalizado no rodapé
const opcoes = {
  pathLogo: './assets/logo-empresa.png',
  cancelada: false,
  textoRodape: 'Meu Sistema Danfe' // Texto que aparece no canto inferior direito
};

const pdfDoc = await gerarPDF(xmlContent, opcoes);
pdfDoc.pipe(fs.createWriteStream('./danfe-com-rodape.pdf'));
```

**💡 Resultado Visual do Rodapé:**

```
Impresso em 27/09/2025 às 15:30:45                    Meu Sistema Danfe
    ↑ (lado esquerdo)                                      ↑ (lado direito)

```
```

--------------------------------

### POST /api/gerar-danfe

Source: https://www.npmjs.com/package/nfe-danfe-pdf/index_activetab=code

Generates a PDF DANFE from XML content. It accepts XML data and an optional logo path in the request body and returns a PDF file.

```APIDOC
## POST /api/gerar-danfe

### Description
Generates a PDF DANFE from XML content. It accepts XML data and an optional logo path in the request body and returns a PDF file.

### Method
POST

### Endpoint
/api/gerar-danfe

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **xml** (string) - Required - The NFe or NFCe XML content.
- **pathLogo** (string) - Optional - The path to a logo to be included in the DANFE.

### Request Example
```json
{
  "xml": "<nfeProc>...</nfeProc>",
  "pathLogo": "/path/to/your/logo.png"
}
```

### Response
#### Success Response (200)
- **application/pdf** - The generated PDF DANFE file.

#### Response Example
(Binary PDF content returned with appropriate headers)

#### Error Response (500)
- **error** (string) - A message indicating an error occurred during PDF generation.
```

--------------------------------

### Define custom options for DANFE PDF generation (TypeScript)

Source: https://www.npmjs.com/package/nfe-danfe-pdf/index_activetab=code

TypeScript type definition for the `OpcoesPDF` object, which allows customization of the DANFE PDF generation. It specifies optional parameters like logo path, cancellation status, and custom footer text.

```typescript
type OpcoesPDF = {
  pathLogo?: string; // Caminho para logo da empresa
  cancelada?: boolean; // Marcar nota como cancelada
  textoRodape?: string; // Texto personalizado no rodapé do documento
};

```

--------------------------------

### POST /api/gerar-danfe

Source: https://www.npmjs.com/package/nfe-danfe-pdf/index_activetab=readme

Generates a DANFE PDF from provided XML data. It accepts an XML string and an optional logo path in the request body and returns the generated PDF.

```APIDOC
## POST /api/gerar-danfe

### Description
Generates a DANFE PDF from provided XML data. It accepts an XML string and an optional logo path in the request body and returns the generated PDF.

### Method
POST

### Endpoint
/api/gerar-danfe

### Parameters
#### Request Body
- **xml** (string) - Required - The XML content of the NFe.
- **pathLogo** (string) - Optional - The path to the logo to be included in the PDF.

### Request Example
```json
{
  "xml": "<xml>...</xml>",
  "pathLogo": "/path/to/your/logo.png"
}
```

### Response
#### Success Response (200)
- **application/pdf** - The generated DANFE PDF file.

#### Response Example
(Binary PDF data)

#### Error Response (500)
- **error** (string) - 'Erro ao gerar DANFE'
```
```

--------------------------------

### NFe DANFE PDF Generation API

Source: https://www.npmjs.com/package/nfe-danfe-pdf/index_activetab=code

This section details the primary function `gerarPDF` for creating DANFE documents. It includes information on its parameters, return type, and advanced options.

```APIDOC
## `gerarPDF(xml, opcoes?)`

### Description
Generates a DANFE (NF-e or NFC-e) PDF document from XML content.

### Method
Asynchronous Function

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **xml** (string) - Required - The XML content of the NF-e/NFC-e.
- **opcoes** (OpcoesPDF) - Optional - Customization options for the PDF generation.

### Request Example
```javascript
import { gerarPDF } from 'nfe-danfe-pdf';
import fs from 'fs';

async function main() {
  try {
    const xmlContent = fs.readFileSync('./nota-fiscal.xml', 'utf8');
    const pdfDoc = await gerarPDF(xmlContent);
    const writeStream = fs.createWriteStream('./danfe.pdf');
    pdfDoc.pipe(writeStream);
    await new Promise<void>((resolve, reject) => {
      writeStream.on('finish', () => {
        console.log('PDF gerado com sucesso!');
        resolve();
      });
      writeStream.on('error', reject);
      pdfDoc.on('error', reject);
    });
  } catch (error) {
    console.error('Erro:', error);
  }
}

main();
```

### Response
#### Success Response (Promise<PDFKit.PDFDocument>)
- **PDFKit.PDFDocument** - A PDF document object that can be piped to a stream.

#### Response Example
```javascript
import { gerarPDF } from 'nfe-danfe-pdf';
import fs from 'fs';

const xmlContent = fs.readFileSync('./nfe.xml', 'utf8');

const opcoes = {
  pathLogo: './assets/logo-empresa.png',
  cancelada: false,
  textoRodape: 'Meu Sistema Danfe'
};

const pdfDoc = await gerarPDF(xmlContent, opcoes);
pdfDoc.pipe(fs.createWriteStream('./danfe-personalizado.pdf'));
pdfDoc.on('end', () => {
  console.log('✅ DANFE gerado com sucesso!');
});
pdfDoc.end();
```

### Type `OpcoesPDF`
```typescript
type OpcoesPDF = {
  pathLogo?: string; // Caminho para logo da empresa
  cancelada?: boolean; // Marcar nota como cancelada
  textoRodape?: string; // Texto personalizado no rodapé do documento
};
```

### Parameter Details
- **`pathLogo`**: Path to the company logo image file (PNG, JPG, etc.).
- **`cancelada`**: Boolean indicating if the note should be visually marked as canceled.
- **`textoRodape`**: Custom text appearing on the right side of the document's footer.
```

--------------------------------

### POST /api/gerar-danfe

Source: https://www.npmjs.com/package/nfe-danfe-pdf/index_activetab=dependencies

Generates a DANFE PDF from XML content. It processes the XML, generates the PDF, and returns it as a downloadable file.

```APIDOC
## POST /api/gerar-danfe

### Description
This endpoint accepts XML content and optionally a logo path, then generates and returns a DANFE PDF document.

### Method
POST

### Endpoint
/api/gerar-danfe

### Parameters
#### Request Body
- **xml** (string) - Required - The NFe XML content.
- **pathLogo** (string) - Optional - The path to the logo to be included in the PDF.
- **textoRodape** (string) - Optional - Text to be displayed at the bottom of the PDF.

### Request Example
```json
{
  "xml": "<nfeProc>...</nfeProc>",
  "pathLogo": "/path/to/logo.png",
  "textoRodape": "Meu Sistema Danfe"
}
```

### Response
#### Success Response (200)
- **application/pdf** - The generated DANFE PDF document.

#### Response Example
(Binary stream of a PDF file, with headers indicating `Content-Type: application/pdf` and `Content-Disposition: attachment; filename="danfe.pdf"`)

#### Error Response (500)
- **json** - An error message.

```json
{
  "error": "Erro ao gerar DANFE"
}
```
```

--------------------------------

### Generate NFe DANFE PDF with Vue.js and TypeScript

Source: https://www.npmjs.com/package/nfe-danfe-pdf/index_activetab=dependents

This Vue.js component allows users to generate a NFe DANFE PDF by sending XML content and an optional logo path to a backend API. It uses axios for HTTP requests and handles the downloaded PDF blob. The component manages a loading state during the PDF generation process.

```typescript
<template>
  <div>
    <button
      @click="gerarDanfe"
      :disabled="isGenerating"
      class="px-4 py-2 bg-green-500 text-white rounded hover:bg-green-600 disabled:opacity-50"
    >
      {{ isGenerating ? 'Gerando...' : 'Gerar DANFE' }}
    </button>
  </div>
</template>

<script setup lang="ts">
import { ref } from 'vue';
import axios from 'axios';

interface Props {
  xmlContent: string;
  logoPath?: string;
}

const props = defineProps<Props>();
const isGenerating = ref(false);

const gerarDanfe = async () => {
  isGenerating.value = true;

  try {
    const response = await axios.post(
      '/api/gerar-danfe',
      {
        xml: props.xmlContent,
        pathLogo: props.logoPath
      },
      {
        responseType: 'blob'
      }
    );

    // Download do PDF
    const blob = new Blob([response.data], { type: 'application/pdf' });
    const url = URL.createObjectURL(blob);

    const link = document.createElement('a');
    link.href = url;
    link.download = 'danfe.pdf';
    link.click();

    URL.revokeObjectURL(url);
  } catch (error) {
    console.error('Erro ao gerar DANFE:', error);
  } finally {
    isGenerating.value = false;
  }
};
</script>
```

--------------------------------

### POST /api/gerar-danfe

Source: https://www.npmjs.com/package/nfe-danfe-pdf/index_activetab=versions

API endpoint to generate a DANFE PDF from XML data. It accepts XML content and an optional logo path in the request body and returns a PDF file.

```APIDOC
## POST /api/gerar-danfe

### Description
Generates a DANFE PDF from the provided XML content. This endpoint is designed to be called from the client-side or other services.

### Method
POST

### Endpoint
/api/gerar-danfe

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **xml** (string) - Required - The XML content of the NFe or NFCe.
- **pathLogo** (string) - Optional - The path to the logo to be included in the PDF.

### Request Example
```json
{
  "xml": "<nfeProc>...</nfeProc>",
  "pathLogo": "/path/to/your/logo.png"
}
```

### Response
#### Success Response (200)
- **application/pdf** - The generated DANFE PDF file.

#### Response Example
(Binary PDF data stream)

#### Error Response (500)
- **error** (string) - "Erro ao gerar DANFE"

```

--------------------------------

### Generate DANFE PDF with NestJS

Source: https://www.npmjs.com/package/nfe-danfe-pdf/index

This code illustrates how to build a NestJS controller to generate DANFE PDFs. It defines a POST endpoint '/gerar' that accepts XML, optional logo path, and footer text. The generated PDF is sent as a response. It relies on NestJS decorators and the 'nfe-danfe-pdf' package.

```typescript
import { Controller, Post, Body, Res, HttpStatus } from '@nestjs/common';
import { Response } from 'express';
import { gerarPDF } from 'nfe-danfe-pdf';

@Controller('danfe')
export class DanfeController {
  @Post('gerar')
  async gerarDanfe(
    @Body('xml') xml: string,
    @Body('pathLogo') pathLogo?: string,
    @Body('textoRodape') textoRodape?: string,
    @Res() res: Response
  ) {
    try {
      const pdfDoc = await gerarPDF(xml, { pathLogo, textoRodape });

      res.setHeader('Content-Type', 'application/pdf');
      pdfDoc.pipe(res);
      pdfDoc.end();
    } catch (error) {
      res.status(HttpStatus.INTERNAL_SERVER_ERROR).json({ message: 'Erro ao gerar DANFE' });
    }
  }
}
```

--------------------------------

### Generate DANFE PDF with Express.js

Source: https://www.npmjs.com/package/nfe-danfe-pdf/index

This snippet demonstrates how to create a POST endpoint using Express.js to generate a DANFE PDF. It expects XML content, an optional logo path, and footer text in the request body. The generated PDF is streamed directly as the response. Dependencies include 'express' and 'nfe-danfe-pdf'.

```javascript
import express from 'express';
import { gerarPDF } from 'nfe-danfe-pdf';

const app = express();

app.post('/gerar-danfe', async (req, res) => {
  try {
    const { xml, pathLogo, textoRodape } = req.body;
    const pdfDoc = await gerarPDF(xml, { pathLogo, textoRodape });

    res.setHeader('Content-Type', 'application/pdf');
    res.setHeader('Content-Disposition', 'attachment; filename="danfe.pdf"');

    pdfDoc.pipe(res);
    pdfDoc.end();
  } catch (error) {
    res.status(500).json({ erro: 'Erro ao gerar DANFE' });
  }
});
```

--------------------------------

### Generate NFe DANFE PDF with Angular and TypeScript

Source: https://www.npmjs.com/package/nfe-danfe-pdf/index_activetab=dependents

This Angular service and component facilitate the generation of NFe DANFE PDFs. The service handles the HTTP POST request to the backend API with XML content and an optional logo path, returning an Observable of a Blob. The component uses the service to trigger PDF generation and download, managing a loading state.

```typescript
import { Injectable } from '@angular/core';
import { HttpClient, HttpHeaders } from '@angular/common/http';
import { Observable } from 'rxjs';

@Injectable({
  providedIn: 'root'
})
export class DanfeService {
  constructor(private http: HttpClient) {}

  gerarDanfe(xmlContent: string, logoPath?: string): Observable<Blob> {
    const headers = new HttpHeaders({
      'Content-Type': 'application/json'
    });

    return this.http.post(
      '/api/gerar-danfe',
      {
        xml: xmlContent,
        pathLogo: logoPath
      },
      {
        headers,
        responseType: 'blob'
      }
    );
  }

  downloadPdf(blob: Blob, filename: string = 'danfe.pdf'): void {
    const url = window.URL.createObjectURL(blob);
    const link = document.createElement('a');
    link.href = url;
    link.download = filename;
    document.body.appendChild(link);
    link.click();
    document.body.removeChild(link);
    window.URL.revokeObjectURL(url);
  }
}
```

```typescript
import { Component } from '@angular/core';
import { DanfeService } from './danfe.service';

@Component({
  selector: 'app-danfe',
  template: `
    <button
      (click)="gerarDanfe()"
      [disabled]="isGenerating"
      class="px-4 py-2 bg-purple-500 text-white rounded hover:bg-purple-600 disabled:opacity-50"
    >
      {{ isGenerating ? 'Gerando...' : 'Gerar DANFE' }}
    </button>
  `
})
export class DanfeComponent {
  isGenerating = false;

  constructor(private danfeService: DanfeService) {}

  gerarDanfe(): void {
    this.isGenerating = true;

    this.danfeService.gerarDanfe(this.xmlContent).subscribe({
      next: (blob) => {
        this.danfeService.downloadPdf(blob);
        this.isGenerating = false;
      },
      error: (error) => {
        console.error('Erro ao gerar DANFE:', error);
        this.isGenerating = false;
      }
    });
  }

  // Propriedade que deve ser definida com o XML
  xmlContent = ''; // Seu XML aqui
}
```

--------------------------------

### Generate and Download DANFE PDF with React and TypeScript

Source: https://www.npmjs.com/package/nfe-danfe-pdf/index

This React component, written in TypeScript, shows how to trigger DANFE PDF generation from a front-end application. It uses Axios to send a POST request to a '/api/gerar-danfe' endpoint, specifying the XML content and optional parameters. The component handles the PDF response as a blob and initiates a file download. It manages loading states and displays error messages.

```typescript
import React, { useState } from 'react';
import axios from 'axios';

interface DanfeGeneratorProps {
  xmlContent: string;
}

const DanfeGenerator: React.FC<DanfeGeneratorProps> = ({ xmlContent }) => {
  const [isGenerating, setIsGenerating] = useState(false);

  const gerarDanfe = async () => {
    setIsGenerating(true);
    try {
      const response = await axios.post(
        '/api/gerar-danfe',
        {
          xml: xmlContent,
          pathLogo: '/assets/logo.png',
          textoRodape: 'Meu Sistema Danfe'
        },
        {
          responseType: 'blob' // Importante para receber PDF
        }
      );

      // Criar URL do blob e fazer download
      const blob = new Blob([response.data], { type: 'application/pdf' });
      const url = window.URL.createObjectURL(blob);

      // Criar link de download
      const link = document.createElement('a');
      link.href = url;
      link.download = 'danfe.pdf';
      document.body.appendChild(link);
      link.click();

      // Cleanup
      document.body.removeChild(link);
      window.URL.revokeObjectURL(url);
    } catch (error) {
      console.error('Erro ao gerar DANFE:', error);
      alert('Erro ao gerar DANFE');
    } finally {
      setIsGenerating(false);
    }
  };

  return (
    <button
      onClick={gerarDanfe}
      disabled={isGenerating}
      className="px-4 py-2 bg-blue-500 text-white rounded hover:bg-blue-600 disabled:opacity-50"
    >
      {isGenerating ? 'Gerando...' : 'Gerar DANFE'}
    </button>
  );
};

export default DanfeGenerator;
```

--------------------------------

### NFe DANFE PDF Generation API

Source: https://www.npmjs.com/package/nfe-danfe-pdf/index_activetab=dependents

This section details the main function for generating DANFE PDFs using the nfe-danfe-pdf package. It includes information on parameters, return types, and custom options.

```APIDOC
## `gerarPDF(xml, opcoes?)`

### Description
Generates a DANFE (NF-e and NFC-e) PDF document from provided XML content with optional customization.

### Method
`gerarPDF`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
**`xml`** (string) - Required - The XML content of the NF-e or NFC-e.

**`opcoes`** (`OpcoesPDF`) - Optional - Custom settings for PDF generation.

### `OpcoesPDF` Type Definition
```typescript
type OpcoesPDF = {
  pathLogo?: string; // Path to the company logo image
  cancelada?: boolean; // Mark the document as canceled
  textoRodape?: string; // Custom text for the document footer
};
```

### Request Example
```javascript
import { gerarPDF } from 'nfe-danfe-pdf';
import fs from 'fs';

async function main() {
  try {
    const xmlContent = fs.readFileSync('./nota-fiscal.xml', 'utf8');
    const pdfDoc = await gerarPDF(xmlContent);
    const writeStream = fs.createWriteStream('./danfe.pdf');
    pdfDoc.pipe(writeStream);
    await new Promise<void>((resolve, reject) => {
      writeStream.on('finish', resolve);
      writeStream.on('error', reject);
      pdfDoc.on('error', reject);
    });
    console.log('PDF generated successfully!');
  } catch (error) {
    console.error('Error:', error);
  }
}

main();
```

### Response
#### Success Response (Promise<PDFKit.PDFDocument>)
- **PDFDocument** (object) - A PDFKit document object that can be piped to a stream.

#### Response Example
```javascript
import { gerarPDF } from 'nfe-danfe-pdf';
import fs from 'fs';

const xmlContent = fs.readFileSync('./nfe.xml', 'utf8');

const opcoes = {
  pathLogo: './assets/logo-empresa.png',
  cancelada: false,
  textoRodape: 'Meu Sistema Danfe'
};

const pdfDoc = await gerarPDF(xmlContent, opcoes);
pdfDoc.pipe(fs.createWriteStream('./danfe-personalizado.pdf'));
pdfDoc.on('end', () => {
  console.log('✅ DANFE generated successfully!');
});
pdfDoc.end();
```
```

--------------------------------

### NFe DANFE PDF API

Source: https://www.npmjs.com/package/nfe-danfe-pdf/index_activetab=readme

The core function `gerarPDF` allows for the generation of DANFE (NF-e and NFC-e) in PDF format. It accepts the XML content of the fiscal document and optional configuration options.

```APIDOC
## gerarPDF(xml, opcoes?)

### Description
Generates a DANFE (NF-e and NFC-e) PDF document from the provided XML content.

### Method
Function Call

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **xml** (string) - Required - The XML content of the NF-e/NFC-e.
- **opcoes** (OpcoesPDF) - Optional - Custom configuration options for PDF generation.

### Request Example
```javascript
import { gerarPDF } from 'nfe-danfe-pdf';
import fs from 'fs';

async function main() {
  try {
    const xmlContent = fs.readFileSync('./nota-fiscal.xml', 'utf8');
    const pdfDoc = await gerarPDF(xmlContent);
    const writeStream = fs.createWriteStream('./danfe.pdf');
    pdfDoc.pipe(writeStream);
    await new Promise<void>((resolve, reject) => {
      writeStream.on('finish', resolve);
      writeStream.on('error', reject);
      pdfDoc.on('error', reject);
    });
    console.log('PDF gerado com sucesso!');
  } catch (error) {
    console.error('Erro:', error);
  }
}

main();
```

### Response
#### Success Response (200)
- **PDFKit.PDFDocument** - A PDF document stream that can be piped to a file or response.

#### Response Example
(The response is a stream, not a JSON object. See example usage for piping.)

### Type: OpcoesPDF
```typescript
type OpcoesPDF = {
  pathLogo?: string; // Path to the company logo image
  cancelada?: boolean; // Mark the note as cancelled
  textoRodape?: string; // Custom text for the document footer
};
```

### Detailed Parameter Descriptions
- **`pathLogo`**: Path to the company logo image file (PNG, JPG, etc.).
- **`cancelada`**: Determines if the note should be visually marked as cancelled.
- **`textoRodape`**: Custom text that appears on the right side of the document footer (e.g., 'Meu Sistema Danfe').

### Example with Custom Footer
```javascript
import { gerarPDF } from 'nfe-danfe-pdf';
import fs from 'fs';

const xmlContent = fs.readFileSync('./nfe.xml', 'utf8');

const opcoes = {
  pathLogo: './assets/logo-empresa.png',
  cancelada: false,
  textoRodape: 'Meu Sistema Danfe' 
};

const pdfDoc = await gerarPDF(xmlContent, opcoes);
pdfDoc.pipe(fs.createWriteStream('./danfe-com-rodape.pdf'));
```
```

--------------------------------

### NFe DANFE PDF Generation API

Source: https://www.npmjs.com/package/nfe-danfe-pdf/index

This section details the primary function `gerarPDF` for generating DANFE PDFs. It covers basic and advanced usage, including customization options.

```APIDOC
## `gerarPDF(xml, opcoes?)`

### Description
Generates a DANFE (NF-e or NFC-e) PDF document from an XML content.

### Method
```javascript
gerarPDF(xml: string, opcoes?: OpcoesPDF): Promise<PDFKit.PDFDocument>
```

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```javascript
import { gerarPDF } from 'nfe-danfe-pdf';
import fs from 'fs';

async function main() {
  try {
    const xmlContent = fs.readFileSync('./nota-fiscal.xml', 'utf8');
    const pdfDoc = await gerarPDF(xmlContent);
    const writeStream = fs.createWriteStream('./danfe.pdf');
    pdfDoc.pipe(writeStream);
    await new Promise<void>((resolve, reject) => {
      writeStream.on('finish', () => resolve());
      writeStream.on('error', reject);
      pdfDoc.on('error', reject);
    });
    console.log('PDF gerado com sucesso!');
  } catch (error) {
    console.error('Erro:', error);
  }
}

main();
```

### Response
#### Success Response (200)
Returns a PDFKit.PDFDocument object that can be piped to a file stream or other output.

#### Response Example
```javascript
// The response is a PDF document stream, not a JSON object.
// Example of piping to a file:
// pdfDoc.pipe(fs.createWriteStream('./danfe.pdf'));
```

### Type `OpcoesPDF`

#### Description
Optional configuration object for customizing PDF generation.

#### Fields
- **`pathLogo`** (string) - Optional - Path to the company's logo image file (e.g., PNG, JPG).
- **`cancelada`** (boolean) - Optional - If true, marks the DANFE visually as canceled. Defaults to `false`.
- **`textoRodape`** (string) - Optional - Custom text to display in the right corner of the document's footer.
```

--------------------------------

### Define OpcoesPDF type for DANFE generation

Source: https://www.npmjs.com/package/nfe-danfe-pdf/index_activetab=dependencies

This TypeScript type definition outlines the available options for customizing the DANFE PDF generation. It includes parameters for the logo path, a boolean to indicate if the note is canceled, and custom footer text. These options allow for tailored PDF output.

```typescript
type OpcoesPDF = {
  pathLogo?: string; // Caminho para logo da empresa
  cancelada?: boolean; // Marcar nota como cancelada
  textoRodape?: string; // Texto personalizado no rodapé do documento
};
```
Tokens:
Raw