nfets 0.0.2 → 0.0.10

package/dist/index.d.cts

@@ -0,0 +1,681 @@
+import { KeyObject, X509Certificate } from 'node:crypto';
+import * as _nfets_core_shared_either from '@nfets/core/shared/either';
+import { Either as Either$1 } from '@nfets/core/shared/either';
+import { NFeTsError as NFeTsError$1 } from '@nfets/core/domain/errors/nfets-error';
+import { ReadCertificateResponse as ReadCertificateResponse$1 } from '@nfets/core/domain/entities/certificate/certificate';
+import { SignatureAlgorithm as SignatureAlgorithm$1 } from '@nfets/core/domain/entities/signer/algo';
+import * as _nfets_core_domain from '@nfets/core/domain';
+import { SignerOptions as SignerOptions$1, SignedEntity as SignedEntity$1, StrategyPattern as StrategyPattern$1, XmlToolkit as XmlToolkit$1, NFeTsError as NFeTsError$2 } from '@nfets/core/domain';
+import { ValidationError as ValidationError$1, ValidationOptions } from 'class-validator';
+import { Decimal as Decimal$1 } from 'decimal.js';
+import { Decimal as Decimal$2, DecimalValue as DecimalValue$1 } from '@nfets/core/domain/entities/calculator/decimal';
+import { CacheAdapter as CacheAdapter$1 } from '@nfets/core/domain/repositories/cache-adapter';
+import { CertificateRepository as CertificateRepository$1 } from '@nfets/core/domain/repositories/certificate-repository';
+import { HttpClient as HttpClient$1 } from '@nfets/core/domain/repositories/http-client';
+import { Agent } from 'node:https';
+import { RemoteTransmissionRepository as RemoteTransmissionRepository$1 } from '@nfets/core/domain/repositories/remote-transmission-repository';
+import { Client as Client$1, SendTransmissionPayload as SendTransmissionPayload$1, ExtractReturnType as ExtractReturnType$1 } from '@nfets/core/domain/entities/transmission/payload';
+import * as Xml2js from 'xml2js';
+import * as _nfets_core from '@nfets/core';
+import * as _nfets_nfe_domain_entities_xml_builder_nfe_det_xml_builder from '@nfets/nfe/domain/entities/xml-builder/nfe-det-xml-builder';
+import { ProdBuilder, AssembleDetXmlBuilder } from '@nfets/nfe/domain/entities/xml-builder/nfe-det-xml-builder';
+import { DeepPartial as DeepPartial$1 } from '@nfets/core/shared';
+import { InfNFeAttributes, InfNFe as InfNFe$1 } from '@nfets/nfe/domain/entities/nfe/inf-nfe';
+import { Ide } from '@nfets/nfe/domain/entities/nfe/inf-nfe/ide';
+import { Cobr } from '@nfets/nfe/domain/entities/nfe/inf-nfe/cobr';
+import { Emit } from '@nfets/nfe/domain/entities/nfe/inf-nfe/emit';
+import { Pag } from '@nfets/nfe/domain/entities/nfe/inf-nfe/pag';
+import { Transp } from '@nfets/nfe/domain/entities/nfe/inf-nfe/transp';
+import { Total } from '@nfets/nfe/domain/entities/nfe/inf-nfe/total';
+import { InfIntermed } from '@nfets/nfe/domain/entities/nfe/inf-nfe/infintermed';
+import { Exporta } from '@nfets/nfe/domain/entities/nfe/inf-nfe/exporta';
+import { Compra } from '@nfets/nfe/domain/entities/nfe/inf-nfe/compra';
+import { Cana } from '@nfets/nfe/domain/entities/nfe/inf-nfe/cana';
+import { InfRespTec } from '@nfets/nfe/domain/entities/nfe/inf-nfe/infresptec';
+import { InfSolicNFF } from '@nfets/nfe/domain/entities/nfe/inf-nfe/inf-solic-nff';
+import { InfAdic } from '@nfets/nfe/domain/entities/nfe/inf-nfe/infadic';
+import { Avulsa } from '@nfets/nfe/domain/entities/nfe/inf-nfe/avulsa';
+import { AutXML } from '@nfets/nfe/domain/entities/nfe/inf-nfe/autxml';
+import { Local } from '@nfets/nfe/domain/entities/nfe/inf-nfe/local';
+import { Dest } from '@nfets/nfe/domain/entities/nfe/inf-nfe/dest';
+import { INfeXmlBuilder, InfNFeBuilder, IdeBuilder } from '@nfets/nfe/domain/entities/xml-builder/nfe-xml-builder';
+import { NFe as NFe$1 } from '@nfets/nfe/infrastructure/dto/nfe/nfe';
+import { DetBuilderAggregator } from '@nfets/nfe/application/aggregator/det-builder-aggregator';
+import { TotalBuilderAggregator } from '@nfets/nfe/application/aggregator/total-builder-aggregator';
+import { AccessKey, VerifiedAccessKey } from '@nfets/nfe/domain/entities/acess-keys/access-key';
+import { NFe as NFe$2, NFeAttributes } from '@nfets/nfe/domain/entities/nfe/nfe';
+import { Det } from '@nfets/nfe/domain/entities/nfe/inf-nfe/det';
+import { InfNFeSupl as InfNFeSupl$1 } from '@nfets/nfe/domain/entities/nfe/inf-nfe-supl';
+
+declare const SignatureNamespace: "http://www.w3.org/2000/09/xmldsig#";
+declare const CanonicalizationMethod$1: "http://www.w3.org/TR/2001/REC-xml-c14n-20010315";
+declare enum SignatureMethod$1 {
+    RSA_SHA1 = "http://www.w3.org/2000/09/xmldsig#rsa-sha1",
+    RSA_SHA256 = "http://www.w3.org/2001/04/xmldsig-more#rsa-sha256"
+}
+declare enum SignatureAlgorithm {
+    SHA1 = "sha1",
+    SHA256 = "sha256"
+}
+declare enum DigestAlgorithm {
+    SHA1 = "http://www.w3.org/2000/09/xmldsig#sha1",
+    SHA256 = "http://www.w3.org/2001/04/xmlenc#sha256"
+}
+
+interface SignedInfo {
+    CanonicalizationMethod: CanonicalizationMethod;
+    SignatureMethod: SignatureMethod;
+    Reference: Reference;
+}
+interface CanonicalizationMethod {
+    $: {
+        Algorithm: 'http://www.w3.org/TR/2001/REC-xml-c14n-20010315';
+    };
+}
+interface SignatureMethod {
+    $: {
+        Algorithm: `${SignatureMethod$1}`;
+    };
+}
+interface Reference {
+    Transforms: Transforms;
+    DigestMethod: DigestMethod;
+    DigestValue: string;
+    $: {
+        URI: string;
+    };
+}
+interface Transforms {
+    Transform: [
+        Transform<'http://www.w3.org/2000/09/xmldsig#enveloped-signature'>,
+        Transform<'http://www.w3.org/TR/2001/REC-xml-c14n-20010315'>
+    ];
+}
+interface Transform<T extends string> {
+    $: {
+        Algorithm: T;
+    };
+}
+interface DigestMethod {
+    $: {
+        Algorithm: `${DigestAlgorithm}`;
+    };
+}
+interface KeyInfo {
+    X509Data: X509Data;
+}
+interface X509Data {
+    X509Certificate: string;
+}
+interface Signature {
+    $: {
+        xmlns: typeof SignatureNamespace;
+    };
+    SignedInfo: SignedInfo;
+    SignatureValue: string;
+    KeyInfo: KeyInfo;
+}
+
+declare class NFeTsError extends Error {
+}
+
+declare const defaultBuilderOptions: BuilderOptions;
+interface XmlDeclarationAttributes {
+    version: string;
+    encoding?: string | undefined;
+    standalone?: boolean | undefined;
+}
+interface RenderOptions {
+    pretty?: boolean | undefined;
+    indent?: string | undefined;
+    newline?: string | undefined;
+}
+interface BuilderOptions {
+    attrkey?: string | undefined;
+    charkey?: string | undefined;
+    rootName?: string | undefined;
+    renderOpts?: RenderOptions | undefined;
+    xmldec?: XmlDeclarationAttributes | undefined;
+    doctype?: 'xml';
+    headless?: boolean | undefined;
+    allowSurrogateChars?: boolean | undefined;
+    cdata?: boolean | undefined;
+}
+
+declare const defaultParserOptions: ParserOptions;
+interface ParserOptions {
+    trim?: boolean;
+    normalizeTags?: boolean;
+    normalize?: boolean;
+    explicitRoot?: boolean;
+    xmlns?: boolean;
+    explicitArray?: boolean;
+    preserveChildrenOrder?: boolean;
+    strict?: boolean;
+    chunkSize?: number;
+}
+
+type Either<L, R> = Left<L> | Right<R>;
+declare class Left<L> {
+    readonly value: L;
+    constructor(value: L);
+    isLeft(): this is Left<L>;
+    isRight(): this is never;
+}
+declare class Right<R> {
+    readonly value: R;
+    constructor(value: R);
+    isLeft(): this is never;
+    isRight(): this is Right<R>;
+}
+declare const left: <L = never>(l: L) => Left<L>;
+declare const right: <R = never>(a?: R) => Right<R>;
+
+declare const defaultCanonicalizeOptions: CanonicalizeOptions;
+interface CanonicalizeOptions {
+    includeComments: boolean;
+    exclusive: boolean;
+}
+
+interface XmlToolkit {
+    parse<T>(xml: string, options?: ParserOptions): Promise<T>;
+    build(object: object, options?: BuilderOptions): Promise<string>;
+    validate(xml: string, xsdPathReference: string, xsdFilename: string): Promise<Either<NFeTsError, void>>;
+    canonicalize(xml: string, options?: CanonicalizeOptions): string;
+    digest(xml: string, algorithm: SignatureAlgorithm, options?: CanonicalizeOptions): string;
+    getNode(xml: string, tag: string): string | null;
+    getAttribute(xml: string, tag: string): string | null;
+    appendNode(xml: string, node: string): string;
+}
+
+interface CertificateRepository {
+    read(pfxPathOrBase64: string, password: string): Promise<Either$1<NFeTsError$1, ReadCertificateResponse$1>>;
+    sign(content: string, privateKey: KeyObject, algorithm: SignatureAlgorithm$1): Promise<Either$1<NFeTsError$1, string>>;
+    getStringPublicKey(certificate: KeyObject): string;
+    getStringPrivateKey(privateKey: KeyObject): string;
+}
+
+declare abstract class Signer {
+    protected readonly toolkit: XmlToolkit;
+    protected readonly certificateRepository: CertificateRepository;
+    protected readonly algorithm: SignatureAlgorithm;
+    protected readonly canonical: CanonicalizeOptions;
+    constructor(toolkit: XmlToolkit, certificateRepository: CertificateRepository, algorithm?: SignatureAlgorithm, canonical?: CanonicalizeOptions);
+    protected assemble(SignedInfo: SignedInfo, SignatureValue: string, certificate: KeyObject): {
+        $: {
+            xmlns: "http://www.w3.org/2000/09/xmldsig#";
+        };
+        SignedInfo: SignedInfo;
+        SignatureValue: string;
+        KeyInfo: {
+            X509Data: {
+                X509Certificate: string;
+            };
+        };
+    };
+    protected signedInfo(node: string, mark: string): {
+        CanonicalizationMethod: {
+            $: {
+                Algorithm: "http://www.w3.org/TR/2001/REC-xml-c14n-20010315";
+            };
+        };
+        SignatureMethod: {
+            $: {
+                Algorithm: SignatureMethod$1;
+            };
+        };
+        Reference: {
+            $: {
+                URI: string;
+            };
+            Transforms: {
+                Transform: [{
+                    $: {
+                        Algorithm: "http://www.w3.org/2000/09/xmldsig#enveloped-signature";
+                    };
+                }, {
+                    $: {
+                        Algorithm: "http://www.w3.org/TR/2001/REC-xml-c14n-20010315";
+                    };
+                }];
+            };
+            DigestMethod: {
+                $: {
+                    Algorithm: DigestAlgorithm;
+                };
+            };
+            DigestValue: string;
+        };
+    };
+    private digest;
+    protected signOrLeft(signedInfo: SignedInfo, privateKey: KeyObject): Promise<Either<NFeTsError, string>>;
+    private get transforms();
+    private get digestAlgorithm();
+    private get signatureMethod();
+}
+
+interface ReadCertificateResponse {
+    password: string;
+    ca: X509Certificate[];
+    certificate: X509Certificate;
+    privateKey: KeyObject;
+}
+
+interface Namespaced {
+    $: {
+        xmlns: string;
+    };
+    [key: string]: unknown;
+}
+declare class EntitySigner extends Signer {
+    sign<T extends Namespaced, K extends keyof T = keyof T>(content: T, options: SignerOptions$1<K>, cert: ReadCertificateResponse): Promise<Either<NFeTsError, SignedEntity$1<T>>>;
+    private ns;
+}
+
+interface SignerOptions<T = string> {
+    tag: T;
+    mark: string;
+}
+type SignedEntity<T extends object> = T & {
+    Signature: Signature;
+};
+
+declare class XmlSigner extends Signer {
+    sign(xml: string, options: SignerOptions, cert: ReadCertificateResponse): Promise<Left<NFeTsError> | Right<string>>;
+}
+
+declare const ValidateErrorsMetadata = "__ValidateErrors__";
+declare const mapConstraintsToErrors: (errors: ValidationError$1[], parent?: string) => string[];
+declare const Validates: <T extends object>(klass: new () => T) => (_target: object, property: string | symbol, descriptor: TypedPropertyDescriptor<(payload: T, ...args: object[]) => any>) => void;
+
+declare const SkipValidationMetadata = "__SkipValidation__";
+declare const SkipValidation: () => MethodDecorator;
+declare const SkipAllValidations: () => ClassDecorator;
+
+declare const IsDecimal: (validationOptions?: ValidationOptions) => PropertyDecorator;
+
+interface ChoiceGroup {
+    properties: [string, ...string[]];
+    required?: boolean;
+}
+interface ChoiceOptions extends ValidationOptions, ChoiceGroup {
+}
+declare const Choice: (options: ChoiceOptions) => ClassDecorator;
+
+declare const plainToInstance: <T extends object>(payload: object, klass: new () => T) => T;
+
+interface TransformDecimalArgs extends ValidationOptions {
+    fixed?: number;
+}
+declare const TransformDecimal: ({ fixed, ...args }?: TransformDecimalArgs) => PropertyDecorator;
+
+interface TransformToDateStringArgs extends ValidationOptions {
+    format?: string;
+}
+declare const TransformDateString: (args?: TransformToDateStringArgs) => (target: object, propertyKey: string | symbol) => void;
+
+interface StateCodeValidatorStrategy extends StrategyPattern$1<string, boolean> {
+    execute(stateCode: string): boolean;
+}
+
+declare class StateCodeAcValidator implements StateCodeValidatorStrategy {
+    execute(stateCode: string): boolean;
+}
+
+declare class StateCodeAlValidator implements StateCodeValidatorStrategy {
+    execute(stateCode: string): boolean;
+}
+
+declare class StateCodeAmValidator implements StateCodeValidatorStrategy {
+    execute(stateCode: string): boolean;
+}
+
+declare class StateCodeApValidator implements StateCodeValidatorStrategy {
+    execute(stateCode: string): boolean;
+}
+
+declare class StateCodeBaValidator implements StateCodeValidatorStrategy {
+    execute(stateCode: string): boolean;
+}
+
+declare class StateCodeCeValidator implements StateCodeValidatorStrategy {
+    execute(stateCode: string): boolean;
+}
+
+declare class StateCodeDfValidator implements StateCodeValidatorStrategy {
+    execute(stateCode: string): boolean;
+}
+
+declare class StateCodeEsValidator implements StateCodeValidatorStrategy {
+    execute(stateCode: string): boolean;
+}
+
+declare class StateCodeGoValidator implements StateCodeValidatorStrategy {
+    execute(stateCode: string): boolean;
+}
+
+declare class StateCodeMaValidator implements StateCodeValidatorStrategy {
+    execute(stateCode: string): boolean;
+}
+
+declare class StateCodeMgValidator implements StateCodeValidatorStrategy {
+    execute(stateCode: string): boolean;
+}
+
+declare class StateCodeMsValidator implements StateCodeValidatorStrategy {
+    execute(stateCode: string): boolean;
+}
+
+declare class StateCodeMtValidator implements StateCodeValidatorStrategy {
+    execute(stateCode: string): boolean;
+}
+
+declare class StateCodePaValidator implements StateCodeValidatorStrategy {
+    execute(stateCode: string): boolean;
+}
+
+declare class StateCodePbValidator implements StateCodeValidatorStrategy {
+    execute(stateCode: string): boolean;
+}
+
+declare class StateCodePeValidator implements StateCodeValidatorStrategy {
+    execute(stateCode: string): boolean;
+}
+
+declare class StateCodePiValidator implements StateCodeValidatorStrategy {
+    execute(stateCode: string): boolean;
+}
+
+declare class StateCodePrValidator implements StateCodeValidatorStrategy {
+    execute(stateCode: string): boolean;
+}
+
+declare class StateCodeRjValidator implements StateCodeValidatorStrategy {
+    execute(stateCode: string): boolean;
+}
+
+declare class StateCodeRnValidator implements StateCodeValidatorStrategy {
+    execute(stateCode: string): boolean;
+}
+
+declare class StateCodeRoValidator implements StateCodeValidatorStrategy {
+    execute(stateCode: string): boolean;
+}
+
+declare class StateCodeRrValidator implements StateCodeValidatorStrategy {
+    execute(stateCode: string): boolean;
+}
+
+declare class StateCodeRsValidator implements StateCodeValidatorStrategy {
+    execute(stateCode: string): boolean;
+}
+
+declare class StateCodeScValidator implements StateCodeValidatorStrategy {
+    execute(stateCode: string): boolean;
+}
+
+declare class StateCodeSeValidator implements StateCodeValidatorStrategy {
+    execute(stateCode: string): boolean;
+}
+
+declare class StateCodeSpValidator implements StateCodeValidatorStrategy {
+    execute(stateCode: string): boolean;
+}
+
+declare class StateCodeToValidator implements StateCodeValidatorStrategy {
+    execute(stateCode: string): boolean;
+}
+
+type DecimalValue = string | number | bigint;
+
+declare const UF: {
+    readonly AC: "12";
+    readonly AL: "27";
+    readonly AM: "13";
+    readonly AP: "16";
+    readonly BA: "29";
+    readonly CE: "23";
+    readonly DF: "53";
+    readonly ES: "32";
+    readonly GO: "52";
+    readonly MA: "21";
+    readonly MG: "31";
+    readonly MS: "50";
+    readonly MT: "51";
+    readonly PA: "15";
+    readonly PB: "25";
+    readonly PE: "26";
+    readonly PI: "22";
+    readonly PR: "41";
+    readonly RJ: "33";
+    readonly RN: "24";
+    readonly RO: "11";
+    readonly RR: "14";
+    readonly RS: "43";
+    readonly SC: "42";
+    readonly SE: "28";
+    readonly SP: "35";
+    readonly TO: "17";
+};
+type StateCode = (typeof UF)[keyof typeof UF];
+type StateAcronym = keyof typeof UF;
+
+declare const Environment: {
+    readonly Production: "1";
+    readonly Homolog: "2";
+};
+type EnvironmentCode = (typeof Environment)[keyof typeof Environment];
+
+interface StrategyPattern<T, R> {
+    execute(...args: T[]): R;
+}
+
+type HeaderValue = string | string[] | number | boolean | null;
+type HttpClientHeaders = Record<string, HeaderValue>;
+type ResponseType = 'arraybuffer' | 'json';
+interface RequestConfig {
+    headers?: HttpClientHeaders;
+    responseType?: ResponseType;
+}
+interface HttpResponse<T = unknown> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: HttpClientHeaders;
+}
+interface HttpClient {
+    get<T = unknown, R = HttpResponse<T>>(url: string, config?: RequestConfig): Promise<R>;
+}
+
+type Client = Record<string, (args: any, opt?: RequestConfig) => Promise<any>>;
+type KnownKeys<T> = keyof {
+    [K in keyof T as {} extends Record<K, 1> ? never : K]: T[K];
+};
+type SendTransmissionPayload<C extends Client> = {
+    [M in KnownKeys<C> & string]: {
+        url: string;
+        method: M;
+        root: string;
+        payload: Parameters<C[M]>[0];
+    };
+}[KnownKeys<C> & string];
+type ExtractReturnType<C extends Client, P extends SendTransmissionPayload<C>> = P extends {
+    method: infer M extends keyof C;
+} ? Awaited<ReturnType<C[M]>> : never;
+
+interface TransmitterOptions {
+    certificate?: ReadCertificateResponse;
+    contingency?: boolean;
+}
+interface Transmitter<C extends Client> {
+    configure(options: TransmitterOptions): Transmitter<C>;
+}
+
+declare class ValidationError extends NFeTsError {
+}
+
+interface CacheAdapter {
+    get<T>(key: string): Promise<T | null>;
+    has(key: string): Promise<boolean>;
+    set(key: string, value: unknown): Promise<boolean>;
+}
+
+interface RemoteTransmissionRepository<C extends Client> {
+    setCertificate(certificate: ReadCertificateResponse): RemoteTransmissionRepository<C>;
+    send<P extends SendTransmissionPayload<C>>(params: P): Promise<Either<NFeTsError, ExtractReturnType<C, P>>>;
+}
+
+declare class Decimal extends Decimal$1 implements Decimal$2 {
+    static from(value: DecimalValue$1 | Decimal): Decimal$2;
+    static newOrZero(value?: DecimalValue$1 | Decimal): Decimal$2;
+    static newOrUndefined(value?: DecimalValue$1 | Decimal): Decimal$2 | undefined;
+}
+
+declare class MemoryCacheAdapter implements CacheAdapter$1 {
+    private cache;
+    get<T>(key: string): Promise<T | null>;
+    has(key: string): Promise<boolean>;
+    set(key: string, value: unknown): Promise<boolean>;
+}
+
+declare class NativeCertificateRepository implements CertificateRepository$1 {
+    private readonly httpClient;
+    private readonly cache;
+    constructor(httpClient: HttpClient$1, cache?: CacheAdapter$1);
+    read(pfxPathOrBase64: string, password: string): Promise<Either$1<NFeTsError$1, ReadCertificateResponse$1>>;
+    sign(content: string, privateKey: KeyObject, algorithm?: SignatureAlgorithm$1): Promise<_nfets_core_shared_either.Left<NFeTsError$1> | _nfets_core_shared_either.Right<string>>;
+    getStringPublicKey(certificate: KeyObject): string;
+    getStringPrivateKey(privateKey: KeyObject): string;
+    private getPfxBuffer;
+    private getCacheKey;
+    private hitBufferOnCache;
+    private isValidRemoteUrl;
+}
+
+declare class NullCacheAdapter implements CacheAdapter$1 {
+    get<T>(_: string): Promise<T | null>;
+    has(_: string): Promise<boolean>;
+    set(_: string, __: unknown): Promise<boolean>;
+}
+
+declare class SoapRemoteTransmissionRepository<C extends Client$1> implements RemoteTransmissionRepository$1<C> {
+    private readonly toolkit;
+    private readonly certificateRepository;
+    private certificate?;
+    constructor(toolkit: XmlToolkit$1, certificateRepository: CertificateRepository$1);
+    setCertificate(certificate: ReadCertificateResponse$1): this;
+    protected get httpsAgent(): Agent;
+    protected get defaultSoapHeaders(): {
+        'Content-Type': string;
+    };
+    send<P extends SendTransmissionPayload$1<C>>(params: P): Promise<_nfets_core_shared_either.Left<_nfets_core_domain.NFeTsError> | _nfets_core_shared_either.Right<ExtractReturnType$1<C, P>>>;
+}
+
+declare class Xml2JsToolkit implements XmlToolkit {
+    private readonly xml2js;
+    constructor(xml2js?: typeof Xml2js);
+    validate(xml: string, xsdPathReference: string, xsdFilename: string): Promise<Left<NFeTsError> | Right<never>>;
+    parse<T>(xml: string, options?: ParserOptions): Promise<T>;
+    build(object: object, options?: BuilderOptions): Promise<string>;
+    digest(xml: string, algorithm: SignatureAlgorithm, options?: CanonicalizeOptions): string;
+    canonicalize(xml: string, options?: CanonicalizeOptions): string;
+    getNode(xml: string, tag: string): string | null;
+    getAttribute(xml: string, tag: string): string | null;
+    appendNode(xml: string, node: string): string;
+    private hash;
+    private clear;
+}
+
+declare const leftFromError: (error: unknown) => Left<NFeTsError>;
+
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+
+declare const unreachable: (_: never) => never;
+
+declare class NfeXmlBuilder implements INfeXmlBuilder {
+    private readonly builder;
+    private readonly data;
+    protected readonly root = "NFe";
+    protected readonly $det: DetBuilderAggregator | undefined;
+    protected readonly $total: TotalBuilderAggregator | undefined;
+    protected readonly nfeDetXmlBuilder: _nfets_nfe_domain_entities_xml_builder_nfe_det_xml_builder.DetBuilder & ProdBuilder;
+    static create(builder: XmlToolkit$1): InfNFeBuilder & IdeBuilder;
+    protected constructor(builder: XmlToolkit$1);
+    infNFe($: InfNFeAttributes): this;
+    ide(payload: Ide): this;
+    emit(payload: Emit): this;
+    avulsa(payload: Avulsa): this;
+    dest(payload: Dest): this;
+    retirada(payload: Local): this;
+    entrega(payload: Local): this;
+    autXML(payload: AutXML): this;
+    det<T>(items: [T, ...T[]], build: (ctx: ProdBuilder, item: T) => AssembleDetXmlBuilder): this;
+    total(payload: Total): this;
+    increment(callback: (context: DeepPartial$1<Total>) => DeepPartial$1<Total>): this;
+    transp(payload: Transp): this;
+    cobr(payload: Cobr): this;
+    pag(payload: Pag): this;
+    infIntermed(payload: InfIntermed): this;
+    infAdic(payload: InfAdic): this;
+    exporta(payload: Exporta): this;
+    compra(payload: Compra): this;
+    cana(payload: Cana): this;
+    infRespTec(payload: InfRespTec): this;
+    infSolicNFF(payload: InfSolicNFF): this;
+    quiet(): this;
+    toObject(): _nfets_core.Left<NFeTsError$2> | _nfets_core.Right<NFe$1>;
+    assemble(): Promise<_nfets_core.Left<NFeTsError$2> | _nfets_core.Right<string>>;
+    private errors;
+    private collect;
+    private fillAccessKeyIfEmpty;
+}
+
+declare class AccessKeyBuilder {
+    compile(payload: AccessKey): string;
+    decompile(accessKey: string): VerifiedAccessKey | undefined;
+    private code;
+    private isCodeValid;
+    private verifyingDigit;
+}
+
+declare class NFe implements NFe$2 {
+    $: NFeAttributes;
+    infNFe: InfNFe$1;
+}
+
+declare class InfNFe implements InfNFe$1 {
+    $: InfNFeAttributes;
+    ide: Ide;
+    emit: Emit;
+    avulsa?: Avulsa;
+    dest?: Dest;
+    retirada?: Local;
+    entrega?: Local;
+    autXML?: AutXML[];
+    det: [Det, ...Det[]];
+    total: Total;
+    transp: Transp;
+    cobr?: Cobr;
+    pag: Pag;
+    infIntermed?: InfIntermed;
+    infAdic?: InfAdic;
+    exporta?: Exporta;
+    compra?: Compra;
+    cana?: Cana;
+    infRespTec?: InfRespTec;
+    infSolicNFF?: InfSolicNFF;
+}
+
+declare class InfNFeSupl implements InfNFeSupl$1 {
+    qrCode: string;
+    urlChave: string;
+}
+
+declare class NFCe {
+    infNFe: InfNFe;
+    infNFeSupl: InfNFeSupl;
+}
+
+export { AccessKeyBuilder, type BuilderOptions, type CacheAdapter, CanonicalizationMethod$1 as CanonicalizationMethod, type CanonicalizeOptions, type CertificateRepository, Choice, type ChoiceOptions, type Client, Decimal, type DecimalValue, type DeepPartial, DigestAlgorithm, type Either, EntitySigner, Environment, type EnvironmentCode, type ExtractReturnType, type HeaderValue, type HttpClient, type HttpClientHeaders, type HttpResponse, IsDecimal, type KnownKeys, Left, MemoryCacheAdapter, NFCe, NFe, NFeTsError, NativeCertificateRepository, NfeXmlBuilder, NullCacheAdapter, type ParserOptions, type ReadCertificateResponse, type RemoteTransmissionRepository, type RenderOptions, type RequestConfig, type ResponseType, Right, type SendTransmissionPayload, type Signature, SignatureAlgorithm, SignatureMethod$1 as SignatureMethod, SignatureNamespace, type SignedEntity, type SignedInfo, Signer, type SignerOptions, SkipAllValidations, SkipValidation, SkipValidationMetadata, SoapRemoteTransmissionRepository, type StateAcronym, type StateCode, StateCodeAcValidator, StateCodeAlValidator, StateCodeAmValidator, StateCodeApValidator, StateCodeBaValidator, StateCodeCeValidator, StateCodeDfValidator, StateCodeEsValidator, StateCodeGoValidator, StateCodeMaValidator, StateCodeMgValidator, StateCodeMsValidator, StateCodeMtValidator, StateCodePaValidator, StateCodePbValidator, StateCodePeValidator, StateCodePiValidator, StateCodePrValidator, StateCodeRjValidator, StateCodeRnValidator, StateCodeRoValidator, StateCodeRrValidator, StateCodeRsValidator, StateCodeScValidator, StateCodeSeValidator, StateCodeSpValidator, StateCodeToValidator, type StrategyPattern, TransformDateString, TransformDecimal, type TransformDecimalArgs, type TransformToDateStringArgs, type Transforms, type Transmitter, type TransmitterOptions, UF, ValidateErrorsMetadata, Validates, ValidationError, Xml2JsToolkit, type XmlDeclarationAttributes, XmlSigner, type XmlToolkit, defaultBuilderOptions, defaultCanonicalizeOptions, defaultParserOptions, left, leftFromError, mapConstraintsToErrors, plainToInstance, right, unreachable };