API Reference

import {
  createDte, calculateTotals, stampDte, signDte, loadCertificate,
  sendToSii, getStatus, toXml, parseCaf,
  DteError, DTE_TYPES, VAT_RATE,
  type Dte, type DteType, type LineItem, type Totals, type Caf,
  type StampedDte, type SignedDte, type Certificate,
} from 'dte-sdk'

function createDte(input: CreateDteInput): Dte

interface CreateDteInput {
  type: DteType
  folio: number
  issuedAt?: string              // 'YYYY-MM-DD', defaults to today in America/Santiago
  issuer: {
    rut: string
    businessName: string
    activity: string
    acteco: number | number[]    // one or more economic activity codes
    address: string
    commune: string
    city?: string
  }
  receiver: {
    rut: string
    businessName: string
    activity?: string
    address?: string
    commune?: string
    city?: string
    email?: string
  }
  items: LineItem[]              // 1 to 60 lines
  references?: Reference[]       // required for types 56 and 61
  paymentMethod?: 'cash' | 'credit' | 'free'
  dueDate?: string               // 'YYYY-MM-DD'
}
 
interface Reference {
  type: DteType | 'SET'          // 'SET' for the SII's certification test set
  folio: number | string
  date: string                   // 'YYYY-MM-DD'
  code?: 1 | 2 | 3               // 1 = voids document, 2 = fixes text, 3 = fixes amounts
  reason?: string
}

function calculateTotals(dte: Dte): Totals
function calculateTotals(
  items: LineItem[],
  options?: { type?: DteType; vatRate?: number; grossPrices?: boolean },
): Totals

calculateTotals([{ name: 'Licencia anual', quantity: 1, unitPrice: 120000 }])
// { net: 120000, exempt: 0, vatRate: 19, vat: 22800, total: 142800 }
 
calculateTotals([{ name: 'Soporte mensual', quantity: 1, unitPrice: 11900 }], { type: 39 })
// { net: 10000, exempt: 0, vatRate: 19, vat: 1900, total: 11900 }

function parseCaf(xml: string): Caf

const caf = parseCaf(await readFile('./caf/33.xml', 'latin1'))
 
caf.type         // 33
caf.issuerRut    // '76.123.456-0'
caf.range        // { from: 1001, to: 2000 }
caf.authorizedAt // 'YYYY-MM-DD'
caf.expiresAt    // 'YYYY-MM-DD'

function stampDte(
  dte: Dte,
  caf: Caf | string,             // a parsed Caf or the raw CAF XML
  options?: { stampedAt?: Date },
): StampedDte

function loadCertificate(pfx: Uint8Array, password: string): Promise<Certificate>

function signDte(stamped: StampedDte, certificate: Certificate): Promise<SignedDte>

function sendToSii(
  docs: SignedDte | SignedDte[],
  options: {
    certificate: Certificate
    environment: 'certification' | 'production'
    senderRut: string                        // RUT of the certificate owner
    resolution: { number: number; date: string }
    signal?: AbortSignal
  },
): Promise<{ trackId: string; receivedAt: string }>

const { trackId, receivedAt } = await sendToSii(signed, {
  certificate,
  environment: 'certification',
  senderRut: '15.234.567-4',
  resolution: { number: 0, date: '2026-09-01' },
  signal: AbortSignal.timeout(30_000),
})
// trackId: '0234567890'

function getStatus(
  trackId: string,
  options: {
    certificate: Certificate
    environment: 'certification' | 'production'
    issuerRut: string
  },
): Promise<Status>
 
type Status = {
  state: 'received' | 'accepted' | 'accepted_with_objections' | 'rejected'
  documents: {
    type: DteType
    folio: number
    state: 'received' | 'accepted' | 'accepted_with_objections' | 'rejected'
    reason?: string
  }[]
}

function toXml(
  doc: Dte | StampedDte | SignedDte,
  options?: { pretty?: boolean; encoding?: 'ISO-8859-1' | 'UTF-8' },
): string

toXml(invoice, { pretty: true }) // readable, unsigned XML for previews
toXml(signed)                    // the exact signed XML, ISO-8859-1

type DteType = 33 | 34 | 39 | 41 | 46 | 52 | 56 | 61

interface LineItem {
  name: string
  description?: string
  quantity: number
  unitPrice: number
  unit?: string                  // unit of measure, e.g. 'UN' or 'KG'
  discountPercent?: number       // 0 to 100
  exempt?: boolean               // keep this line out of the IVA base
}

interface Totals {
  net: number      // taxable amount
  exempt: number   // exempt amount
  vatRate: number  // 19
  vat: number      // IVA
  total: number    // net + exempt + vat
}

// Simplified: every property is readonly, all the way down.
interface Dte extends CreateDteInput {
  issuedAt: string          // always resolved
  totals: Totals
}
 
interface StampedDte extends Dte {
  ted: string               // the <TED> XML
  pdf417: string            // barcode payload for the printed version
}
 
interface SignedDte extends StampedDte {
  xml: string               // the signed document
  signedAt: string          // ISO 8601 timestamp
}

interface Caf {
  readonly type: DteType
  readonly issuerRut: string
  readonly range: { readonly from: number; readonly to: number }
  readonly authorizedAt: string  // 'YYYY-MM-DD'
  readonly expiresAt: string     // 'YYYY-MM-DD'
}

import type { createDte, getStatus, DteError } from 'dte-sdk'
 
type CreateDteInput = Parameters<typeof createDte>[0]
type Reference = NonNullable<CreateDteInput['references']>[number]
type Status = Awaited<ReturnType<typeof getStatus>>
type DteErrorCode = DteError['code']

import { DTE_TYPES, VAT_RATE } from 'dte-sdk'
 
VAT_RATE      // 19
DTE_TYPES[33] // 'Factura electrónica'
DTE_TYPES[61] // 'Nota de crédito electrónica'

class DteError extends Error {
  readonly code:
    | 'MISSING_FIELD' | 'INVALID_RUT' | 'INVALID_AMOUNT'
    | 'FOLIO_OUT_OF_RANGE' | 'CAF_MISMATCH' | 'CAF_EXPIRED'
    | 'CERTIFICATE_INVALID' | 'SII_UNAVAILABLE' | 'SII_REJECTED'
}

import { stampDte, DteError } from 'dte-sdk'
 
try {
  stampDte(invoice, caf)
} catch (error) {
  if (error instanceof DteError && error.code === 'CAF_EXPIRED') {
    // Request a new CAF for this document type, then stamp again.
  }
  throw error
}