nfets 0.0.15 → 0.0.17

package/dist/core/index.d.cts

@@ -1,351 +1,18 @@
-import { X509Certificate, KeyObject } from 'node:crypto';
-import { E as Either, N as NFeTsError, L as Left, R as Right } from '../either-CdHd_Yt7.cjs';
-export { l as left, r as right } from '../either-CdHd_Yt7.cjs';
-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, CertificateInfo as CertificateInfo$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 { x as NFeTsError, Q as Signer, M as SignerOptions, a as ReadCertificateResponse, W as Left, Y as Right, a0 as Decimal$2, D as DecimalValue, y as CacheAdapter, z as CertificateRepository, J as HttpClient, R as ReadCertificateRequest, V as Either, d as SignatureAlgorithm, m as Client, L as RemoteTransmissionRepository, w as XmlToolkit, n as SendTransmissionPayload, o as ExtractReturnType, P as ParserOptions, B as BuilderOptions, s as CanonicalizeOptions } from '../types-BVhE6D84.cjs';
+export { b as CanonicalizationMethod, C as CertificateInfo, $ as DeepPartial, e as DigestAlgorithm, U as EntitySigner, E as Environment, j as EnvironmentCode, H as HeaderValue, A as HttpClientHeaders, I as HttpResponse, K as KnownKeys, N as Namespaced, u as RenderOptions, G as RequestConfig, F as ResponseType, l as Signature, c as SignatureMethod, S as SignatureNamespace, O as SignedEntity, k as SignedInfo, i as StateAcronym, g as StateAcronyms, h as StateCode, f as StateCodes, T as Transforms, q as Transmitter, p as TransmitterOptions, X as XmlDeclarationAttributes, t as defaultBuilderOptions, r as defaultCanonicalizeOptions, v as defaultParserOptions, Z as left, _ as right } from '../types-BVhE6D84.cjs';
 import { ValidationError as ValidationError$1, ValidationOptions } from 'class-validator';
+import { X509Certificate, KeyObject } from 'node:crypto';
 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];
-
-type Namespaced<T extends object = object> = T & {
-    $?: {
-        xmlns: string;
-    };
-};
-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;
-    getCertificateInfo(certificate: X509Certificate): CertificateInfo$1;
-}
-
-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>>;
 }
@@ -383,7 +50,7 @@ interface TransformToDateStringArgs extends ValidationOptions {
 }
 declare const TransformDateString: (args?: TransformToDateStringArgs) => (target: object, propertyKey: string | symbol) => void;
 
-interface StateCodeValidatorStrategy extends StrategyPattern$1<string, boolean> {
+interface StateCodeValidatorStrategy extends StrategyPattern<string, boolean> {
     execute(stateCode: string): boolean;
 }
 
@@ -513,24 +180,24 @@ declare class ASN1 {
 }
 
 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;
+    static from(value: DecimalValue | Decimal): Decimal$2;
+    static newOrZero(value?: DecimalValue | Decimal): Decimal$2;
+    static newOrUndefined(value?: DecimalValue | Decimal): Decimal$2 | undefined;
 }
 
-declare class MemoryCacheAdapter implements CacheAdapter$1 {
+declare class MemoryCacheAdapter implements CacheAdapter {
     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 {
+declare class NativeCertificateRepository implements CertificateRepository {
     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>>;
+    constructor(httpClient: HttpClient, cache?: CacheAdapter);
+    read(request: ReadCertificateRequest): Promise<Either<NFeTsError, ReadCertificateResponse>>;
+    sign(content: string, privateKey: KeyObject, algorithm?: SignatureAlgorithm): Promise<Left<NFeTsError> | Right<string>>;
     getCertificateInfo(certificate: X509Certificate): {
         CNPJ: string | undefined;
         CPF: string | undefined;
@@ -549,29 +216,29 @@ declare class NativeCertificateRepository implements CertificateRepository$1 {
     private isValidRemoteUrl;
 }
 
-declare class NullCacheAdapter implements CacheAdapter$1 {
+declare class NullCacheAdapter implements CacheAdapter {
     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> {
+declare class SoapRemoteTransmissionRepository<C extends Client> implements RemoteTransmissionRepository<C> {
     private readonly toolkit;
     private readonly certificateRepository;
     private certificate?;
-    constructor(toolkit: XmlToolkit$1, certificateRepository: CertificateRepository$1);
-    setCertificate(certificate: ReadCertificateResponse$1): this;
+    constructor(toolkit: XmlToolkit, certificateRepository: CertificateRepository);
+    setCertificate(certificate: ReadCertificateResponse): 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>>>;
+    send<P extends SendTransmissionPayload<C>>(params: P): Promise<Left<NFeTsError> | Right<ExtractReturnType<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>>;
+    validate(xml: string, xsd: 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;
@@ -586,10 +253,6 @@ declare class Xml2JsToolkit implements XmlToolkit {
 
 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, type Namespaced, 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, clearEmptyValues, defaultBuilderOptions, defaultCanonicalizeOptions, defaultParserOptions, leftFromError, mapConstraintsToErrors, plainToInstance, unreachable };
+export { ASN1, BuilderOptions, CacheAdapter, CanonicalizeOptions, CertificateRepository, Choice, type ChoiceOptions, Client, Decimal, DecimalValue, Either, ExtractReturnType, HttpClient, IsDecimal, Left, MemoryCacheAdapter, NFeTsError, NativeCertificateRepository, NullCacheAdapter, ParserOptions, ReadCertificateRequest, ReadCertificateResponse, RemoteTransmissionRepository, Right, SendTransmissionPayload, SignatureAlgorithm, Signer, SignerOptions, SkipAllValidations, SkipValidation, SkipValidationMetadata, SoapRemoteTransmissionRepository, 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, ValidateErrorsMetadata, Validates, ValidationError, Xml2JsToolkit, XmlSigner, XmlToolkit, clearEmptyValues, leftFromError, mapConstraintsToErrors, plainToInstance, unreachable };