Core API (dte-sdk)

import { createDocument, stampDocument, signDocument, createSiiClient, DteError } from 'dte-sdk'

// Typed error thrown by dte-sdk. The message is generic (code + safe keys such as the field name);
// the offending value, if any, lives in `details` so no RUT or free text leaks into logs.
class DteError extends Error {
  readonly code: DteErrorCode
  readonly details: DteErrorDetails
  constructor(code: DteErrorCode, details?: DteErrorDetails)
}
 
// Stable error codes thrown by dte-sdk. Branch on `error.code`, never on the message text.
const DTE_ERROR_CODES: {
  readonly INVALID_RUT: "INVALID_RUT"
  readonly INVALID_DOCUMENT_TYPE: "INVALID_DOCUMENT_TYPE"
  readonly INVALID_FOLIO: "INVALID_FOLIO"
  readonly INVALID_DATE: "INVALID_DATE"
  readonly INVALID_AMOUNT: "INVALID_AMOUNT"
  readonly MISSING_FIELD: "MISSING_FIELD"
  // ... 40 more members
}
 
// The code of a thrown value when it is a `DteError`, else undefined. For results that report
// failures as data.
function errorCode(error: unknown): DteErrorCode | undefined
 
// Type guard for `DteError`.
function isDteError(value: unknown): value is DteError

// SII document type codes supported by dte-sdk, keyed by their English name.
const DOCUMENT_TYPES: {
  readonly invoice: 33
  readonly exemptInvoice: 34
  readonly receipt: 39
  readonly exemptReceipt: 41
  readonly settlementInvoice: 43
  readonly purchaseInvoice: 46
  readonly dispatchGuide: 52
  readonly debitNote: 56
  readonly creditNote: 61
}
 
// Every supported code, ascending.
const DOCUMENT_TYPE_VALUES: readonly DocumentType[] = [33, 34, 39, 41, 43, 46, 52, 56, 61]
 
// Type guard: true when `value` is one of the supported `TipoDTE` codes.
function isDocumentType(value: unknown): value is DocumentType
 
// True for receipts (39, 41): no identified receiver required, no `TasaIVA`, REST channel.
function isReceipt(type: DocumentType): boolean
 
// True for the VAT-exempt types (34, 41): every line is exempt.
function isExemptType(type: DocumentType): boolean
 
// True for debit and credit notes (56, 61), which must reference another document.
function isNote(type: DocumentType): boolean
 
// True when the type needs an identified receiver (everything but receipts).
function requiresReceiver(type: DocumentType): boolean
 
// True when the printed document carries a transferable copy (cedible) and the Ley 19.983
// acknowledgement box.
function isTransferable(type: DocumentType): boolean
 
// Official Spanish name of a document type: `long` (default), `short` (uppercase, no accents) or
// `printed` (uppercase per the SII printed-samples manual).
function documentTypeName(type: DocumentType, variant?: keyof NameVariants): string
 
// SII environments: `certification` (maullin, test) and `production` (palena).
const ENVIRONMENTS: { readonly certification: "certification"; readonly production: "production" }
 
// Type guard for `Environment`.
function isEnvironment(value: unknown): value is Environment
 
// Reference codes used in `Referencia/CodRef` by credit and debit notes.
const REFERENCE_CODES: {
  readonly cancels: 1
  readonly correctsText: 2
  readonly correctsAmounts: 3
}
 
// Transfer reasons for dispatch guides (`IdDoc/IndTraslado`).
const TRANSFER_TYPES: {
  readonly sale: 1
  readonly pendingSale: 2
  readonly consignment: 3
  readonly freeDelivery: 4
  readonly internalTransfer: 5
  readonly otherNonSale: 6
  readonly return: 7
  readonly exportTransfer: 8
  readonly exportSale: 9
}
 
// Who dispatches the goods (`IdDoc/TipoDespacho`).
const DISPATCH_TYPES: {
  readonly byReceiver: 1
  readonly byIssuerToReceiver: 2
  readonly byIssuerToOther: 3
}
 
// Service indicator (`IdDoc/IndServicio`), mandatory on receipts (3 is the common case).
const SERVICE_INDICATORS: {
  readonly periodicServices: 1
  readonly periodicHomeServices: 2
  readonly salesAndServices: 3
  readonly shows: 4
}
 
// Payment terms (`IdDoc/FmaPago`).
const PAYMENT_TERMS: { readonly cash: 1; readonly credit: 2; readonly free: 3 }
 
// Line exemption indicator (`Detalle/IndExe`).
const EXEMPT_INDICATORS: {
  readonly exempt: 1
  readonly nonBillable: 2
  readonly containerDeposit: 3
  readonly notASale: 4
  readonly deduction: 5
  readonly nonBillableNegative: 6
}
 
// Withholding tax codes used in `Totales/ImptoReten/TipoImp`.
const WITHHOLDING_TAX_CODES: { readonly totalVatWithholding: 15 }
 
// VAT rate in force, percent.
const VAT_RATE = 19
 
// RUT of the SII itself, the receiver of every envelope.
const SII_RUT = '60803000-K'
 
// Generic final-consumer RUT used on receipts without an identified buyer.
const FINAL_CONSUMER_RUT = '66666666-6'
 
// `IDK` value that marks a certification-environment CAF.
const CERTIFICATION_KEY_ID = 100

// Maps a domain `Document` to the SII-shaped structure (official tags, schema order). This is the
// only place that knows the tag names; the XML is always rendered from its output.
function toSiiDocument(doc: Document): SiiDocumento
 
// Maps a SII-shaped document back to the domain model (for received DTEs and interop). RUTs are
// validated with rut.ts on the way in.
function fromSiiDocument(sii: SiiDocumento): Document

// Validates a RUT with rut.ts (Modulo 11) and returns it in SII shape. Accepts dotted, hyphenated
// or compact input.
function toSiiRut(value: string, field?: string): SiiRut
 
// Type guard: true when `value` is already a valid RUT in SII shape.
function isSiiRut(value: unknown): value is SiiRut
 
// Splits a SII RUT into body and verifier (what the SII multipart fields `rutSender`/`dvSender`
// need).
function splitSiiRut(rut: SiiRut): { readonly body: string; readonly verifier: string; }

// Normalizes free text for a DTE field: drops apostrophes and double quotes (they break the SII
// signature checks), maps typographic dashes and ellipsis to ASCII, removes anything outside
// ISO-8859-1 (emoji, curly quotes) and trims.
function sanitizeText(text: string | null | undefined): string
 
// Folds text to printable ASCII for the TED (`RSR`, `IT1`): strips diacritics (á→a, ñ→n), expands
// ligatures and special letters (ß→ss, Æ→AE, Þ→TH), then drops every remaining non-ASCII
// character.
function foldToAscii(text: string | null | undefined): string
 
// Sanitizes and cuts text to `maxLength`; with `preserveWords`, backs up to the last space when it
// sits past 70 % of the limit.
function truncateText(
  text: string | null | undefined,
  maxLength: number,
  preserveWords?: boolean,
): string
 
// Throws `FIELD_TOO_LONG` when the (already sanitized) text exceeds the `xs:maxLength` of the SII
// schema. The SII rejects the WHOLE envelope when one document fails the schema, so this fails
// early instead of truncating silently.
function assertMaxLength(value: string, maxLength: number, field: string): void
 
// Encodes text as ISO-8859-1 bytes (what the SII upload endpoints expect). Throws instead of
// truncating a code point above U+00FF to its low byte, which is how corrupted control characters
// used to reach the SII.
function encodeLatin1(text: string): Uint8Array
 
// Decodes ISO-8859-1 bytes to a string (one char per byte).
function decodeLatin1(bytes: Uint8Array): string

// Today's date in Chile as `YYYY-MM-DD` (the SII `FchEmis`/`FchResol` format).
function chileDate(now?: Date): string
 
// Chile-local timestamp `YYYY-MM-DDTHH:MM:SS` without zone or milliseconds (`TmstFirma`,
// `TmstFirmaEnv`, `TSTED`). Never built with `toISOString()`, which is always UTC and put
// envelopes ~3 h in the future ("Error en Carátula").
function chileTimestamp(now?: Date): string
 
// Breaks an instant (default: now) into Chile-local components using `Intl`, never the process
// time zone.
function chileDateTimeParts(now?: Date): ChileDateTimeParts
 
// Normalizes `DD-MM-YYYY`, `DD/MM/YYYY` or `YYYY-MM-DD` (as the SII portal and resolutions show
// dates) to ISO.
function toIsoDate(value: string, field?: string): string
 
// True when `value` is a real calendar date in `YYYY-MM-DD`.
function isIsoDate(value: string): boolean

// Computes a detail line amount with per-line rounding (the SII compares `MontoItem` against
// `QtyItem × PrcItem`).
function calculateLineAmount(input: LineAmountInput): LineAmount
 
// Computes `Totales` from detail lines: net, exempt, VAT (derived from the gross when
// `pricesIncludeVat`), non-billable, withholding for purchase invoices and the total.
function calculateTotals(
  items: readonly Pick<LineItem, "amount" | "exemptIndicator">[],
  options: TotalsOptions,
): Totals

// Builds a normalized `Document` from caller input: validates type, folio and dates, normalizes
// RUTs with rut.ts, sanitizes text and enforces schema lengths (fails early instead of letting the
// SII reject the whole envelope), numbers lines, computes amounts and totals, applies receipt
// defaults (final consumer, `IndServicio=3`) and sets `MntBruto=1` when prices include VAT.
function createDocument(input: DocumentInput, options?: CreateDocumentOptions): Document
 
// `xs:maxLength` of the SII schema per element; `createDocument` enforces them on sanitized text.
const FIELD_LIMITS: {
  readonly RznSoc: 100
  readonly GiroEmis: 80
  readonly DirOrigen: 70
  readonly CmnaOrigen: 20
  readonly CiudadOrigen: 20
  readonly Sucursal: 20
  // ... 29 more members
}
 
// Renders the unsigned `<DTE>` XML: namespaces on the root (the digest inherits them), `ID` on the
// signed element, sections in schema order, the TED verbatim and a line break between sections.
function buildDocumentXml(doc: Document, options?: BuildDocumentXmlOptions): string
 
// Name of the signed element: `Liquidacion` for settlement invoices (43), `Documento` otherwise.
function documentElementName(type: DocumentType): "Documento" | "Liquidacion"
 
// Signs a stamped document with the issuer certificate (enveloped XMLDSig over
// `Documento`/`Liquidacion`). `TmstFirma` is the Chile time of `now`, or `signedAt` as given.
function signDocument(
  doc: StampedDocument,
  certificate: Certificate,
  options?: { readonly now?: Date; readonly signedAt?: string; },
): SignedDocument
 
// Verifies the signature of a `<DTE>` XML (own or received).
function verifyDocumentSignature(xml: string): SignatureVerification
 
// The whole pipeline: create (if needed) → stamp with the CAF → sign with the certificate.
function issueDocument(input: IssueDocumentInput): SignedDocument

// Serializes a plain object to compact XML. Keys become elements in insertion order, `@_name` keys
// become attributes, arrays repeat the element and values are entity-escaped.
function buildXml(value: Readonly<Record<string, unknown>>): string
 
// Parses XML into a plain object (values as strings). Throws `XML_PARSE_FAILED` when not
// well-formed.
function parseXml(xml: string): ParsedXml
 
// Like `parseXml` but drops namespace prefixes (`SII:RESPUESTA` → `RESPUESTA`), handy for SOAP
// responses.
function parseXmlWithoutNamespaces(xml: string): ParsedXml
 
// Text of the first `<tag>…</tag>` occurrence, or `null`. Regex-based, for flat SII responses.
function extractTagContent(xml: string, tag: string): string | null
 
// Decodes the five XML entities (SOAP responses often embed escaped XML).
function decodeXmlEntities(xml: string): string
 
// Escapes a text node value with the five XML entities (`& < > " '`).
function escapeXmlText(value: string): string
 
// Escapes an attribute value quoted with double quotes.
function escapeXmlAttribute(value: string): string
 
// Removes whitespace from a base64 string and wraps it at `width` columns.
function wrapBase64(value: string, width?: number): string
 
// Rewraps `SignatureValue`, `Modulus` and `X509Certificate` at 64 columns, the layout the SII
// expects.
function formatBase64Columns(xml: string): string

// Base64 SHA-1 of `data` encoded as `encoding` (default UTF-8). Used for XMLDSig `DigestValue`.
function sha1Base64(data: string, encoding?: TextEncoding): string
 
// SHA1withRSA (PKCS#1 v1.5) signature of `data`, base64. Deterministic: same key and bytes, same
// signature.
function rsaSha1SignBase64(privateKeyPem: string, data: string, encoding?: TextEncoding): string
 
// Verifies a SHA1withRSA base64 signature against a public key given as modulus/exponent. Never
// throws: malformed input is `false`.
function rsaSha1VerifyBase64(
  publicKey: RsaPublicKeyParts,
  data: string,
  encoding: TextEncoding,
  signatureBase64: string,
): boolean
 
// Public modulus and exponent of a PEM private key (PKCS#1 or PKCS#8).
function rsaPublicKeyParts(privateKeyPem: string): RsaPublicKeyParts
 
// Public modulus and exponent of a PEM certificate.
function rsaPublicKeyPartsFromCertificatePem(certificatePem: string): RsaPublicKeyParts
 
// Parses a PEM certificate into the fields dte-sdk needs.
function parseCertificatePem(certificatePem: string): ParsedCertificate
 
// Base64 body of a PEM certificate (no headers, no whitespace).
function certificateBase64(certificatePem: string): string

// True when `now` is past `notAfter` minus `marginDays`.
function isCertificateExpired(
  certificate: Pick<Certificate, "notAfter">,
  options?: { readonly now?: Date; readonly marginDays?: number; },
): boolean
 
// Whole days until `notAfter` (negative once expired).
function daysUntilExpiry(
  certificate: Pick<Certificate, "notAfter">,
  options?: { readonly now?: Date; },
): number
 
// Builds a `Certificate` from PEM strings (e.g. after `openssl pkcs12 -nodes`). Verifies the key
// matches the certificate and that it is valid now: not expired (`CERT_EXPIRED`) and not before
// its `notBefore` (`CERT_NOT_YET_VALID`, `details.validFrom`). `allowExpired` loads both.
function loadCertificateFromPem(
  input: PemCertificateInput,
  options?: LoadCertificateOptions,
): Certificate
 
// Loads a PKCS#12 (`.pfx`/`.p12`) as a `Certificate`: legacy (3DES/RC2) and modern (PBES2/AES)
// files, shrouded or plain key bags, leaf detection by key, chain ordered leaf → root, RUT from
// the certificate. Like the PEM loader, it throws `CERT_EXPIRED` past `notAfter` and
// `CERT_NOT_YET_VALID` before `notBefore`; `allowExpired` loads both.
function loadCertificateFromPkcs12(
  bytes: Uint8Array,
  password: string,
  options?: LoadCertificateOptions,
): Certificate

// Parses a CAF XML file as downloaded from the SII. Validates structure, type, range and keys (the
// private key `RSASK` must be the pair of the public key `RSAPK` the SII signed), and that the text
// holds one `<CAF` and one `</CAF`, so the `<CAF>` block kept for the TED is the CAF its fields are
// read from. Numeric character references (`&#209;`, `&#xD1;`) in its fields decode as a DOM
// decodes them. Throws `CAF_INVALID`, also for keys that are not a pair, a DOCTYPE or another
// `<CAF` or `</CAF` anywhere in the text, such as in a comment.
function parseCaf(xml: string): Caf
 
// Expiry instant of a CAF: six months after `authorizationDate` (Res. Ex. SII 58/2017) for
// invoices and notes (33, 46, 56, 61), at midnight continental Chile (UTC-4). A day the sixth
// month does not have is its last day: a CAF authorized on 2026-08-31 expires on 2027-02-28, not
// in March. `null` for types that never expire or without a date.
function cafExpiresAt(caf: Pick<Caf, "documentType" | "authorizationDate">): Date | null
 
// True when the CAF has expired or expires within `marginMs` (default one day: the SII rejects
// every document stamped with an expired CAF with `CAF-3-517`, and the envelope may be received
// later than it was stamped).
function isCafExpired(
  caf: Pick<Caf, "documentType" | "authorizationDate">,
  options?: { readonly now?: Date; readonly marginMs?: number; },
): boolean
 
// True when `folio` is an integer inside the CAF range.
function isFolioInRange(caf: Pick<Caf, "range">, folio: number): boolean
 
// Throws `FOLIO_OUT_OF_RANGE` unless `folio` is inside the CAF range.
function assertFolioInRange(caf: Pick<Caf, "range" | "documentType">, folio: number): void
 
// Number of folios the CAF authorizes.
function availableFolios(caf: Pick<Caf, "range">): number
 
// SHA1withRSA signature (base64) of `data` with the CAF private key over its ISO-8859-1 bytes, the
// encoding the TED is transmitted and printed in.
function signWithCaf(caf: Pick<Caf, "privateKeyPem">, data: string): string
 
// Verifies a TED-style signature with the CAF public key (`RSAPK`).
function verifyWithCaf(caf: Pick<Caf, "publicKey">, data: string, signatureBase64: string): boolean
 
// The SII keys that sign the `DA` of every CAF, by `IDK`: 100 for the certification environment
// and 300 for production. Each is the 512-bit RSA key of a self-signed certificate of the SII whose
// serial number is the `IDK`, from CryptoSys and LibreDTE, the same bytes in both.
const SII_CAF_KEYS: SiiCafKeys
 
// The environment of the SII key a CAF names in its `IDK`: `certification` for 100, `production`
// for 300, null for another.
function cafEnvironment(keyId: number): Environment | null
 
// Verifies the SII signature of a CAF (`FRMA`, SHA1withRSA over the `DA`) with the SII key its
// `IDK` names. Takes a CAF file as the SII issues it or the `<CAF>` block a TED carries.
// `unchecked` when no key is known for that `IDK`; `invalid` for a CAF of the other environment
// than `environment` (production by default), whatever its signature, and for an empty `FRMA`,
// whatever its key. Throws `CAF_INVALID` when the text is not XML, holds a DOCTYPE, or has no
// single `CAF` with one `DA` and one `FRMA`.
function verifyCafSignature(cafXml: string, options?: CafSignatureOptions): VerificationStatus

// Stamps a document with a CAF: checks type, issuer, folio range and expiry, builds the exact `DD`
// and signs it with the CAF key (SHA1withRSA over Latin-1 bytes).
function stampDocument(doc: Document, caf: Caf, options?: StampOptions): StampedDocument
 
// Verifies a `TED` XML against the CAF public key: true only when the `<DD>` bytes match the
// `FRMT` signature.
function verifyTed(tedXml: string, caf: Pick<Caf, "publicKey">): boolean
 
// The exact `<DD>…</DD>` string that gets signed and printed in the PDF417.
function buildDdString(fields: Omit<Ted, "signature" | "xml">): string
 
// Wraps a `DD` and its signature in the `TED` element.
function buildTedXml(dd: string, signature: string): string
 
// Folds text to ASCII and then cuts it to 40, the way `RSR` and `IT1` need it (folding may
// lengthen the text).
function tedText(text: string): string

// Builds `SignedInfo`. `referenceId` is the `ID` of the signed element, or `''` for a
// whole-document reference (`URI=""`).
function buildSignedInfo(
  referenceId: string,
  digestValue: string,
  options?: { readonly expandTags?: boolean; readonly includeXsi?: boolean; },
): string
 
// Builds the `Signature` element from a stored `SignedInfo`, the wrapped signature and the key
// material.
function buildSignatureXml(
  signedInfo: string,
  signatureValue: string,
  keyInfo: { readonly modulus: string; readonly exponent: string; readonly certificate: string; },
): string
 
// Signs `elementTag` with an enveloped XMLDSig signature (C14N 1.0, RSA-SHA1) and returns the XML
// with the `Signature` inserted right before `</rootTag>`.
function signEnveloped(
  input: SignEnvelopedInput,
): { readonly xml: string; readonly signature: XmlSignature; }
 
// Signs the whole root element with an enveloped XMLDSig signature (`Reference URI=""`,
// enveloped-signature transform, C14N 1.0, RSA-SHA1) and inserts `Signature` right before the
// closing root tag.
function signRootElement(
  input: SignRootElementInput,
): { readonly xml: string; readonly signature: XmlSignature; }
 
// Verifies the enveloped signature that is a direct child of `rootTag`: locates the signed element
// by the `ID` named in `Reference/@URI` (see `referencedElement`), recomputes its digest and
// checks `SignatureValue` with the `X509Certificate` carried in `KeyInfo`. Only the signature this
// computes passes: one `Reference`, holding the only `DigestValue`, with SHA-1 and no transform but
// enveloped-signature or C14N 1.0 (else `digestValid: false`), under C14N 1.0 and RSA-SHA1 (else
// `signatureValid: false`).
function verifyEnveloped(
  xml: string,
  target: { readonly elementTag: string; readonly rootTag: string; },
): SignatureVerification

// Groups signed documents under a cover: validates the kind, normalizes RUTs and the resolution
// date, counts documents per type (`SubTotDTE`, with 33/61/56 first on `EnvioDTE`) and generates
// the set id.
function createEnvelope(input: CreateEnvelopeInput): Envelope
 
// `PREFIX_dd_mm_yyyy_hh_mm_ss_mmm` in Chile time.
function generateSetId(prefix: string, now?: Date): string
 
// Renders the unsigned envelope: ISO-8859-1 prolog, root with schema location, `SetDTE` with
// `Caratula` and the signed documents one per line (their namespaces stay: the digests depend on
// them).
function buildEnvelopeXml(envelope: Envelope): string
 
// Root element of an envelope kind.
function envelopeRootName(kind: Envelope["kind"]): "EnvioDTE" | "EnvioBOLETA"
 
// Signs the `SetDTE` with the sender certificate.
function signEnvelope(envelope: Envelope, certificate: Certificate): SignedEnvelope
 
// Verifies the `SetDTE` signature of an `EnvioDTE`/`EnvioBOLETA` XML.
function verifyEnvelopeSignature(xml: string): SignatureVerification

// Verifies the documents of a `DTE`, `EnvioDTE` or `EnvioBOLETA` as received from a supplier, and
// the envelope's own signature. Each document is read from its element in the parsed input, never
// from a cut of the text: its signature is checked over forms written from that element, and its
// fields and stamp are read from it. It is checked for: its XMLDSig signature; its TED, whose
// `FRMT` must verify with the key of the CAF the TED carries and whose `DD` must agree with the
// header; that CAF against the document (the issuer, the type, the folio inside the range); and
// the SII's signature over the CAF (`FRMA`) with the SII key of its `IDK` (`SII_CAF_KEYS`, or
// `siiKeys`), for the CAFs of `environment` only (production by default).
function verifyReceivedDocuments(
  xml: string,
  options?: VerifyReceivedDocumentsOptions,
): ReceivedDocumentsVerification

// Side of the purchase and sales book, with its SII value.
const BOOK_OPERATIONS: { readonly sale: "VENTA"; readonly purchase: "COMPRA" }
 
// Kind of purchase and sales book, with its SII value.
const BOOK_KINDS: {
  readonly monthly: "MENSUAL"
  readonly special: "ESPECIAL"
  readonly rectification: "RECTIFICA"
}
 
// How a book reaches the SII: in one go, in segments, the closing of the segments, or a later
// adjustment.
const BOOK_SUBMISSIONS: {
  readonly total: "TOTAL"
  readonly partial: "PARCIAL"
  readonly final: "FINAL"
  readonly adjustment: "AJUSTE"
}
 
// Document types the book schema admits (`DoctoType` of `LibroCV_v10.xsd`), electronic or not.
const BOOK_DOCUMENT_TYPES: readonly [
  29, 30, 32, 33, 34, 35, 38, 39, 40, 41, 43, 45, 46, 48, 53, 55, 56, 60, 61, 101, 102, 103, 104,
  105, 106, 108, 109, 110, 111, 112, 175, 180, 185, 500, 501, 900, 901, 902, 903, 904, 905, 906,
  907, 909, 910, 911, 914, 918, 919, 920, 921, 922, 924
]
 
// Type guard for `BookDocumentType`.
function isBookDocumentType(value: unknown): value is BookDocumentType
 
// Types the format excludes from the detail: report them in `summaryOnlyTotals` (receipts,
// exchange rate adjustments, tickets without invoice, other unregistered records).
const SUMMARY_ONLY_DOCUMENT_TYPES: readonly [35, 38, 39, 41, 48, 105, 500, 501, 919, 920, 922, 924]
 
// Why VAT on a purchase cannot be recovered.
const NON_RECOVERABLE_VAT_CODES: {
  readonly nonTaxableOperations: 1
  readonly lateRegistration: 2
  readonly rejectedExpenses: 3
  readonly freeDeliveries: 4
  readonly other: 9
}
 
// Operation of a guide line in the guide book. `TpoOper` stops at 7 in the schema, so values 8 and
// 9 of `IndTraslado` cannot be reported on a line.
const GUIDE_TRANSFER_TYPES: {
  readonly sale: 1
  readonly pendingSale: 2
  readonly consignment: 3
  readonly demonstration: 4
  readonly internalTransfer: 5
  readonly otherTransfer: 6
  readonly returnGuide: 7
}
 
// Why a guide line is marked: voided before reaching the SII, voided afterwards, or goods partly
// received.
const GUIDE_VOID_CODES: { readonly folio: 1; readonly guide: 2; readonly partialReceipt: 3 }

// The `EnvioLibro` of a purchase and sales book with the official tags, in schema order.
function toSiiPurchaseSalesBook(book: PurchaseSalesBook): SiiEnvioLibro
 
// The `EnvioLibro` of a guide book with the official tags, in schema order.
function toSiiGuideBook(book: GuideBook): SiiEnvioLibroGuia
 
// The `DocumentoConsumoFolios` of a report with the official tags, in schema order.
function toSiiFolioConsumption(report: FolioConsumption): SiiDocumentoConsumoFolios
 
// Adds summaries by document type, and inside each type adds non-recoverable VAT and other taxes
// by code. Rows keep the order of their first appearance, and a row present on one side only is
// kept.
function accumulateBookTotals(
  base: readonly BookTotals[],
  delta: readonly BookTotals[],
): readonly BookTotals[]

// Builds a purchase and sales book (IECV): validates the cover and the zones of its submission,
// normalizes the lines and computes the summaries.
function createPurchaseSalesBook(input: PurchaseSalesBookInput): PurchaseSalesBook
 
// Renders the unsigned `LibroCompraVenta` XML.
function buildPurchaseSalesBookXml(book: PurchaseSalesBook): string
 
// Signs the `EnvioLibro` with the sender certificate (enveloped XMLDSig, `URI="#ID"`).
function signPurchaseSalesBook(
  book: PurchaseSalesBook,
  certificate: Certificate,
): SignedPurchaseSalesBook
 
// Verifies the signature of a `LibroCompraVenta` XML.
function verifyPurchaseSalesBookSignature(xml: string): SignatureVerification

// Builds a guide book: validates the cover and the zones of its submission, normalizes the lines
// and computes the summaries. `TasaImp` and `IVA` are always emitted, 0 when absent.
function createGuideBook(input: GuideBookInput): GuideBook
 
// Renders the unsigned `LibroGuia` XML.
function buildGuideBookXml(book: GuideBook): string
 
// Signs the `EnvioLibro` with the sender certificate (enveloped XMLDSig, `URI="#ID"`).
function signGuideBook(book: GuideBook, certificate: Certificate): SignedGuideBook
 
// Verifies the signature of a `LibroGuia` XML.
function verifyGuideBookSignature(xml: string): SignatureVerification
 
// Adds two guide book summaries, the transfers by operation. Use it to carry the period totals of
// earlier submissions forward.
function accumulateGuideTotals(base: GuideTotals, delta: GuideTotals): GuideTotals

// Builds a folio consumption report (RCOF, now Resumen de Ventas Diarias): one summary per receipt
// type present, 39 first, or one of type 39 in zeros for a day without sales.
function createFolioConsumption(input: FolioConsumptionInput): FolioConsumption
 
// Renders the unsigned `ConsumoFolios` XML.
function buildFolioConsumptionXml(report: FolioConsumption): string
 
// Signs the `DocumentoConsumoFolios` with the sender certificate (enveloped XMLDSig, `URI="#ID"`).
function signFolioConsumption(
  report: FolioConsumption,
  certificate: Certificate,
): SignedFolioConsumption
 
// Verifies the signature of a `ConsumoFolios` XML.
function verifyFolioConsumptionSignature(xml: string): SignatureVerification
 
// Sorts folios and groups the consecutive ones into ranges; a lone folio has `from` equal to `to`.
function compactFolioRanges(folios: readonly number[]): readonly FolioRange[]

// Derives a book line from a document. The counterparty is the receiver when the book owner issued
// the document and the issuer otherwise, which covers sales, purchases received and purchase
// invoices (46) on either side.
function bookEntryFromDocument(
  document: Document,
  options: BookEntryFromDocumentOptions,
): BookEntryInput
 
// Derives a guide book line from a dispatch guide (52). The transfer defaults to a sale, and the
// receiver and the amounts travel only on sales; a non-sale guide reports its total alone.
function guideEntryFromDocument(document: Document): GuideEntryInput
 
// Derives a folio consumption line from a receipt (39 or 41).
function folioConsumptionEntryFromDocument(document: Document): FolioConsumptionEntry

// Base hosts of the DTE web services per environment.
const SII_HOSTS: Readonly<Record<Environment, string>> = {
  certification: 'maullin.sii.cl',
  production: 'palena.sii.cl',
}
 
// SOAP / CGI endpoints per environment (seed, token, upload, status).
const SOAP_ENDPOINTS: Readonly<Record<Environment, SoapEndpoints>>
 
// REST endpoints of the receipts API per environment.
const REST_ENDPOINTS: Readonly<Record<Environment, RestEndpoints>>
 
// Service URLs of the acceptance/claim registry web service (WSRECLAMO v1.2); SOAP calls are
// POSTed here.
const CLAIM_WS_ENDPOINTS: Readonly<Record<Environment, string>>
 
// WSDL of the acceptance/claim registry web service.
const CLAIM_WSDL_ENDPOINTS: Readonly<Record<Environment, string>>
 
// User-Agent the SII upload CGI expects (it rejects modern browser strings).
const UPLOAD_USER_AGENT = 'Mozilla/4.0 ( compatible; PROG 1.0; Windows NT)'

// Default logger: discards everything.
const silentLogger: Logger

// Cache key `${environment}:${channel}:${fingerprint}`: two companies, two environments or two
// channels never share a token.
function tokenCacheKey(
  environment: Environment,
  channel: TokenChannel,
  certificate: Pick<Certificate, "certificateBase64">,
): string
 
// In-memory token cache (per process).
function createMemoryTokenCache(): TokenCache

// Defaults measured against the SII: 6 attempts, 2 s growing ×1.8, capped at 15 s, ±20 % jitter.
const DEFAULT_RETRY_POLICY: RetryPolicy = {
  maxAttempts: 6,
  initialDelayMs: 2000,
  maxDelayMs: 15000,
  backoffMultiplier: 1.8,
  jitterRatio: 0.2,
}
 
// True for errors worth retrying: transport failures, timeouts, unreadable SII pages, `QueryEst*`
// query errors, HTTP 429/405/5xx and the "system blocked" upload status.
function isRetryableError(error: unknown): boolean

// Default transport over `globalThis.fetch` (Node ≥ 20, Deno, Bun) or an injected `fetch`.
// Redirects are not followed: the SII never redirects a well-formed call and following one would
// hide an error page.
function createFetchTransport(options?: { readonly fetch?: FetchLike; }): HttpTransport

// Pure redaction of a whole exchange (URL, headers, bodies and the error reason); the client
// applies it before calling the port, and adapters may reuse it.
function redactExchange(exchange: HttpExchange): HttpExchange
 
// In-memory capture: `exchanges()` returns a copy of everything captured so far.
function createMemoryCapture(): { readonly capture: HttpCapture; readonly exchanges: () => readonly HttpExchange[]; }

// In-memory archive: `records()` returns a copy of everything archived so far.
function createMemoryUploadArchive(): { readonly archive: UploadArchive; readonly records: () => readonly UploadRecord[]; }

// Validates and completes the options into a frozen `SiiClient`. RUTs go through rut.ts; numbers
// must be positive; the default transport is `fetch`, the default cache is in memory, the default
// logger is silent.
function createSiiClient(options: SiiClientOptions): SiiClient

// Builds a SOAP 1.1 envelope (UTF-8 text) with one rpc operation and its parameters as unqualified
// children.
function buildSoapEnvelope(input: SoapEnvelopeInput): string
 
// Parses a SOAP reply without a full XML parse: the SII answers are flat and sometimes carry stray
// entities.
function parseSoapResponse(xml: string): SoapResponse
 
// `multipart/form-data` bytes: the fields in order, then the file part, as the SII's upload CGI
// expects them.
function buildMultipartBody(input: MultipartBodyInput): Uint8Array

// Asks the SII for a seed on the given channel (SOAP `CrSeed` or REST
// `boleta.electronica.semilla`). The seed is a 12-digit string valid for two minutes; it is never
// cached.
function getSeed(sii: SiiClient, channel: TokenChannel, overrides?: CallOverrides): Promise<string>
 
// Signs a seed for `GetTokenFromSeed` / the REST token endpoint: XML declaration, one newline,
// then `<getToken><item><Semilla>…</Semilla></item><Signature…/></getToken>` with no trailing
// newline (the REST endpoint is byte-strict about this layout).
function signSeed(
  seed: string,
  certificate: Pick<Certificate, "privateKeyPem" | "publicKey" | "certificateBase64">,
): string
 
// Returns a valid token for the channel: the cached one while it has not expired, otherwise seed →
// signed seed → token, stored in the cache for `tokenTtlMs`. The DTEWS token and the REST token
// are different things.
function getToken(sii: SiiClient, channel: TokenChannel, overrides?: CallOverrides): Promise<string>
 
// Forgets the cached token of a channel (the next operation authenticates again).
function invalidateToken(sii: SiiClient, channel: TokenChannel): Promise<void>

// Uploads a signed envelope: `EnvioDTE` through `DTEUpload` (ISO-8859-1 multipart), `EnvioBOLETA`
// through the receipts REST API in production or `DTEUpload` in certification (`channel`
// overrides).
function uploadEnvelope(
  sii: SiiClient,
  input: UploadEnvelopeInput,
  overrides?: CallOverrides,
): Promise<UploadReceipt>
 
// Uploads a signed book through `DTEUpload`, as `LibroGuia.xml` for a `LibroGuia` and
// `LibroCV.xml` otherwise unless `fileName` says differently; the XML must declare ISO-8859-1, as
// for `uploadEnvelope` (`INVALID_OPTION { field: 'xml' }` otherwise).
function uploadBook(
  sii: SiiClient,
  input: UploadXmlInput,
  overrides?: CallOverrides,
): Promise<UploadReceipt>
 
// Uploads a signed folio consumption report (RCOF, `ConsumoFolios`) through `DTEUpload` as
// `ConsumoFolios.xml`, unless `fileName` says differently; the XML must declare ISO-8859-1, as for
// `uploadEnvelope` (`INVALID_OPTION { field: 'xml' }` otherwise).
function uploadFolioConsumption(
  sii: SiiClient,
  input: UploadXmlInput,
  overrides?: CallOverrides,
): Promise<UploadReceipt>

// Status of an upload by TrackID: `QueryEstUp` on the `soap` channel (default) or the receipts
// REST envelope status on `rest`.
function queryUploadStatus(
  sii: SiiClient,
  input: QueryUploadStatusInput,
  overrides?: CallOverrides,
): Promise<UploadStatus>
 
// Polls `queryUploadStatus` every `intervalMs` until the status is no longer `pending`, up to
// `timeoutMs`.
function waitForUploadStatus(
  sii: SiiClient,
  input: WaitForUploadStatusInput,
  overrides?: CallOverrides,
): Promise<UploadStatus>
 
// Status of one document: `QueryEstDte` (SOAP, the default for every type except receipts) or the
// receipts REST per-document endpoint (the default for 39 and 41; the REST API answers about ten
// minutes after the upload).
function queryDocumentStatus(
  sii: SiiClient,
  input: QueryDocumentStatusInput,
  overrides?: CallOverrides,
): Promise<DocumentStatus>
 
// Whether the SII already holds a document with this type and folio: `QueryEstDte` (always SOAP),
// asked as the company itself, with the final-consumer receiver, today's date in Chile and amount
// 1, answers by folio existence first.
function folioReceived(
  sii: SiiClient,
  input: FolioReceivedInput,
  overrides?: CallOverrides,
): Promise<boolean | null>

// Registers an action on a received document (`ingresarAceptacionReclamoDoc`): accept content,
// claim content, acknowledge goods, claim partial or total shortfall.
function registerClaim(
  sii: SiiClient,
  input: RegisterClaimInput,
  overrides?: CallOverrides,
): Promise<ClaimResult>
 
// Events registered on a document (`listarEventosHistDoc`).
function listClaimEvents(
  sii: SiiClient,
  input: ClaimDocumentInput,
  overrides?: CallOverrides,
): Promise<ClaimEventsResult>
 
// Whether a document is transferable (`consultarDocDteCedible`): `transferable` follows the 20–25
// codes, null when undetermined.
function queryTransferable(
  sii: SiiClient,
  input: ClaimDocumentInput,
  overrides?: CallOverrides,
): Promise<TransferabilityResult>
 
// When the SII received a document (`consultarFechaRecepcionSii`): the string it returned and that
// string as ISO when it is a date (`DD-MM-YYYY HH:MM:SS`).
function queryReceptionDate(
  sii: SiiClient,
  input: ClaimDocumentInput,
  overrides?: CallOverrides,
): Promise<ReceptionDateResult>
 
// What the receiver did, derived from the latest event of `listClaimEvents` (by date, else by
// position): `accepted` (ACD), `goodsReceived` (ERM), `claimed` (RCD/RFP/RFT), `paidInCash` (PAG),
// `none` (no events, NCA/ENC), `unknown` otherwise.
function receiverStatus(
  sii: SiiClient,
  input: ClaimDocumentInput,
  overrides?: CallOverrides,
): Promise<ReceiverStatusResult>
 
// The receiver's answer from the events of `listClaimEvents` and the reception date of
// `queryReceptionDate`, with no request: `NCA` comes first, then a claim (RCD/RFP/RFT), then
// `ACD`; then `PAG`, a document the SII marked paid in cash, which the registry takes no event on,
// so it has no deadline; past the deadline (the reception day plus eight, Ley 19.983) with none of
// them the document is accepted by law, and before it `ERM` is goods received and anything else
// pending. `ENC` changes nothing. Given the whole result of `listClaimEvents`, with no events and a
// `codResp` other than 15, 16 or 18 (the codes that list events or say there are none), the query
// failed and the answer is `unknown`, never pending or tacitly accepted, as `receiverStatus` reads
// it; events, when the SII sent some, speak whatever the code. Its events alone still work, but
// cannot tell a failed query. `receiverStatus` keeps reading the latest event only. Throws
// `INVALID_DATE` when `today` is not a date.
function receiverAnswer(
  listed:
    | readonly Pick<ClaimEvent, "code">[]
    | { readonly code: number; readonly events: readonly Pick<ClaimEvent, "code">[] },
  receivedAt: string | null,
  today: string,
): ReceiverAnswerResult