nfets 0.0.13 → 0.0.14

package/dist/core/index.d.ts

@@ -0,0 +1,576 @@
+import { X509Certificate, KeyObject } from 'node:crypto';
+import { E as Either, N as NFeTsError, L as Left, R as Right } from '../either-CdHd_Yt7.js';
+export { l as left, r as right } from '../either-CdHd_Yt7.js';
+import { Either as Either$1 } from '@nfets/core/shared/either';
+import { NFeTsError as NFeTsError$1 } from '@nfets/core/domain/errors/nfets-error';
+import { ReadCertificateRequest as ReadCertificateRequest$1, ReadCertificateResponse as ReadCertificateResponse$1 } from '@nfets/core/domain/entities/certificate/certificate';
+import { SignatureAlgorithm as SignatureAlgorithm$1 } from '@nfets/core/domain/entities/signer/algo';
+import { SignerOptions as SignerOptions$1, SignedEntity as SignedEntity$1, StrategyPattern as StrategyPattern$1, XmlToolkit as XmlToolkit$1 } 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';
+
+type DecimalValue = string | number | bigint;
+
+interface ReadCertificateRequest {
+    pfxPathOrBase64: string;
+    password: string;
+}
+interface ReadCertificateResponse {
+    password: string;
+    ca: X509Certificate[];
+    certificate: X509Certificate;
+    privateKey: KeyObject;
+}
+interface CertificateInfo {
+    CNPJ?: string;
+    CPF?: string;
+    O?: string;
+    C?: string;
+    ST?: string;
+    L?: string;
+    CN?: string;
+    OU?: string;
+}
+
+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"
+}
+
+declare const StateCodes: {
+    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";
+};
+declare const StateAcronyms: StateAcronym[];
+type StateCode = (typeof StateCodes)[keyof typeof StateCodes];
+type StateAcronym = keyof typeof StateCodes;
+
+declare const Environment: {
+    readonly Production: "1";
+    readonly Homolog: "2";
+};
+type EnvironmentCode = (typeof Environment)[keyof typeof Environment];
+
+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;
+}
+
+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;
+        xsd: 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;
+}
+interface Transmitter<C extends Client> {
+    configure(options: TransmitterOptions): Transmitter<C>;
+}
+
+declare const defaultCanonicalizeOptions: CanonicalizeOptions;
+interface CanonicalizeOptions {
+    includeComments: boolean;
+    exclusive: boolean;
+}
+
+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;
+}
+
+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;
+    getFirstNode(xml: string): string | null;
+    getAttribute(xml: string, tag: string): string | null;
+    appendNode(xml: string, node: string): string;
+}
+
+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 CertificateRepository {
+    read(request: ReadCertificateRequest$1): Promise<Either$1<NFeTsError$1, ReadCertificateResponse$1>>;
+    sign(content: string, privateKey: KeyObject, algorithm: SignatureAlgorithm$1): Promise<Either$1<NFeTsError$1, string>>;
+    getStringCertificate(certificate: X509Certificate): string;
+    getStringPrivateKey(privateKey: KeyObject): string;
+}
+
+interface RemoteTransmissionRepository<C extends Client> {
+    setCertificate(certificate: ReadCertificateResponse): RemoteTransmissionRepository<C>;
+    send<P extends SendTransmissionPayload<C>>(params: P): Promise<Either<NFeTsError, ExtractReturnType<C, P>>>;
+}
+
+interface SignerOptions<T = string> {
+    tag: T;
+    mark: string;
+}
+type SignedEntity<T extends object> = T & {
+    Signature: Signature;
+};
+
+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: X509Certificate): {
+        $: {
+            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();
+}
+
+declare class EntitySigner extends Signer {
+    sign<T extends object, K extends keyof T = keyof T>(content: T, options: SignerOptions$1<K>, cert: ReadCertificateResponse): Promise<Either<NFeTsError, SignedEntity$1<T>>>;
+    private ns;
+}
+
+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: any[]) => 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;
+}
+
+declare class ASN1 {
+    extractCertificateInfo(certificate: X509Certificate): {
+        CNPJ: string | undefined;
+        CPF: string | undefined;
+        CN: string | undefined;
+        O: string | undefined;
+        OU: string | undefined;
+        ST: string | undefined;
+        L: string | undefined;
+        C: string | undefined;
+    };
+    oid(number: string, publicKey: Buffer): string | undefined;
+    protected length(data: Buffer): number;
+    protected marker(oid: string): Buffer;
+    protected base128(bytes: number[], byte: number, last: boolean): number[];
+}
+
+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(request: ReadCertificateRequest$1): Promise<Either$1<NFeTsError$1, ReadCertificateResponse$1>>;
+    sign(content: string, privateKey: KeyObject, algorithm?: SignatureAlgorithm$1): Promise<Left<NFeTsError$1> | Right<string>>;
+    getStringCertificate(certificate: X509Certificate): 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<Left<NFeTsError> | 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;
+    getFirstNode(xml: 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;
+
+export { ASN1, type BuilderOptions, type CacheAdapter, CanonicalizationMethod$1 as CanonicalizationMethod, type CanonicalizeOptions, type CertificateInfo, type CertificateRepository, Choice, type ChoiceOptions, type Client, Decimal, type DecimalValue, type DeepPartial, DigestAlgorithm, Either, EntitySigner, Environment, type EnvironmentCode, type ExtractReturnType, type HeaderValue, type HttpClient, type HttpClientHeaders, type HttpResponse, IsDecimal, type KnownKeys, Left, MemoryCacheAdapter, NFeTsError, NativeCertificateRepository, NullCacheAdapter, type ParserOptions, type ReadCertificateRequest, 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, StateAcronyms, 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, StateCodes, type StrategyPattern, TransformDateString, TransformDecimal, type TransformDecimalArgs, type TransformToDateStringArgs, type Transforms, type Transmitter, type TransmitterOptions, ValidateErrorsMetadata, Validates, ValidationError, Xml2JsToolkit, type XmlDeclarationAttributes, XmlSigner, type XmlToolkit, defaultBuilderOptions, defaultCanonicalizeOptions, defaultParserOptions, leftFromError, mapConstraintsToErrors, plainToInstance, unreachable };

package/dist/core/index.mjs

@@ -0,0 +1 @@
+import{$,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,_,a,aa,b,ba,c,ca,d,da,e,ea,f,fa,g,ga,h,ha,i,ia,j,ja,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z}from"../chunk-XYOTPYUB.mjs";import"../chunk-3WPW27WV.mjs";import"../chunk-W6MRGYXP.mjs";export{ca as ASN1,b as CanonicalizationMethod,A as Choice,da as Decimal,e as DigestAlgorithm,q as EntitySigner,h as Environment,z as IsDecimal,m as Left,ea as MemoryCacheAdapter,i as NFeTsError,fa as NativeCertificateRepository,ga as NullCacheAdapter,n as Right,d as SignatureAlgorithm,c as SignatureMethod,a as SignatureNamespace,l as Signer,u as SkipAllValidations,t as SkipValidation,s as SkipValidationMetadata,ha as SoapRemoteTransmissionRepository,g as StateAcronyms,D as StateCodeAcValidator,E as StateCodeAlValidator,F as StateCodeAmValidator,G as StateCodeApValidator,H as StateCodeBaValidator,I as StateCodeCeValidator,J as StateCodeDfValidator,K as StateCodeEsValidator,L as StateCodeGoValidator,M as StateCodeMaValidator,N as StateCodeMgValidator,O as StateCodeMsValidator,P as StateCodeMtValidator,Q as StateCodePaValidator,R as StateCodePbValidator,S as StateCodePeValidator,T as StateCodePiValidator,U as StateCodePrValidator,V as StateCodeRjValidator,W as StateCodeRnValidator,X as StateCodeRoValidator,Y as StateCodeRrValidator,Z as StateCodeRsValidator,_ as StateCodeScValidator,$ as StateCodeSeValidator,aa as StateCodeSpValidator,ba as StateCodeToValidator,f as StateCodes,C as TransformDateString,B as TransformDecimal,w as ValidateErrorsMetadata,y as Validates,j as ValidationError,ja as Xml2JsToolkit,r as XmlSigner,o as left,ia as leftFromError,x as mapConstraintsToErrors,v as plainToInstance,p as right,k as unreachable};

package/dist/either-CdHd_Yt7.d.cts

@@ -0,0 +1,20 @@
+declare class NFeTsError extends Error {
+}
+
+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>;
+
+export { type Either as E, Left as L, NFeTsError as N, Right as R, left as l, right as r };

package/dist/either-CdHd_Yt7.d.ts

@@ -0,0 +1,20 @@
+declare class NFeTsError extends Error {
+}
+
+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>;
+
+export { type Either as E, Left as L, NFeTsError as N, Right as R, left as l, right as r };