nfets 0.0.16 → 0.0.18

package/dist/types-BVhE6D84.d.ts

@@ -0,0 +1,405 @@
+import { X509Certificate, KeyObject } from 'node:crypto';
+
+type DecimalRounding = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+type DecimalValue = string | number | bigint;
+interface Decimal {
+    d: number[];
+    e: number;
+    s: number;
+    abs(): Decimal;
+    ceil(): Decimal;
+    comparedTo(n: DecimalValue | Decimal): number;
+    cmp(n: DecimalValue | Decimal): number;
+    decimalPlaces(): number;
+    dp(): number;
+    div(n: DecimalValue | Decimal): Decimal;
+    divToInt(n: DecimalValue | Decimal): Decimal;
+    equals(n: DecimalValue | Decimal): boolean;
+    floor(): Decimal;
+    greaterThan(n: DecimalValue | Decimal): boolean;
+    gt(n: DecimalValue | Decimal): boolean;
+    greaterThanOrEqualTo(n: DecimalValue | Decimal): boolean;
+    gte(n: DecimalValue | Decimal): boolean;
+    isFinite(): boolean;
+    isInteger(): boolean;
+    isInt(): boolean;
+    isNaN(): boolean;
+    isNegative(): boolean;
+    isPositive(): boolean;
+    isZero(): boolean;
+    lessThan(n: DecimalValue | Decimal): boolean;
+    lt(n: DecimalValue | Decimal): boolean;
+    lessThanOrEqualTo(n: DecimalValue | Decimal): boolean;
+    lte(n: DecimalValue | Decimal): boolean;
+    sub(n: DecimalValue | Decimal): Decimal;
+    mod(n: DecimalValue | Decimal): Decimal;
+    naturalExponential(): Decimal;
+    exp(): Decimal;
+    negated(): Decimal;
+    neg(): Decimal;
+    add(n: DecimalValue | Decimal): Decimal;
+    precision(includeZeros?: boolean): number;
+    sd(includeZeros?: boolean): number;
+    round(): Decimal;
+    sqrt(): Decimal;
+    times(n: DecimalValue | Decimal): Decimal;
+    mul(n: DecimalValue | Decimal): Decimal;
+    toExponential(decimalPlaces?: number, rounding?: DecimalRounding): string;
+    toExponential(decimalPlaces: number, rounding: DecimalRounding): string;
+    toFixed(decimalPlaces?: number, rounding?: DecimalRounding): string;
+    toFixed(decimalPlaces: number, rounding: DecimalRounding): string;
+    toFraction(max_denominator?: DecimalValue | Decimal): Decimal[];
+    toJSON(): string;
+    toNumber(): number;
+    pow(n: DecimalValue | Decimal): Decimal;
+    toPrecision(significantDigits?: number, rounding?: DecimalRounding): string;
+    toDecimalPlaces(decimalPlaces?: number, rounding?: DecimalRounding): Decimal;
+    toString(): string;
+    trunc(): Decimal;
+    valueOf(): string;
+}
+
+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;
+}
+
+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;
+}
+
+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>;
+
+interface XmlToolkit {
+    parse<T>(xml: string, options?: ParserOptions): Promise<T>;
+    build(object: object, options?: BuilderOptions): Promise<string>;
+    validate(xml: string, xsd: 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;
+}
+
+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): Promise<Either<NFeTsError, ReadCertificateResponse>>;
+    sign(content: string, privateKey: KeyObject, algorithm: SignatureAlgorithm): Promise<Either<NFeTsError, string>>;
+    getStringCertificate(certificate: X509Certificate): string;
+    getStringPrivateKey(privateKey: KeyObject): string;
+    getCertificateInfo(certificate: X509Certificate): CertificateInfo;
+}
+
+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<K>, cert: ReadCertificateResponse): Promise<Either<NFeTsError, SignedEntity<T>>>;
+    private ns;
+}
+
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+
+export { type DeepPartial as $, type HttpClientHeaders as A, type BuilderOptions as B, type CertificateInfo as C, type DecimalValue as D, Environment as E, type ResponseType as F, type RequestConfig as G, type HeaderValue as H, type HttpResponse as I, type HttpClient as J, type KnownKeys as K, type RemoteTransmissionRepository as L, type SignerOptions as M, type Namespaced as N, type SignedEntity as O, type ParserOptions as P, Signer as Q, type ReadCertificateRequest as R, SignatureNamespace as S, type Transforms as T, EntitySigner as U, type Either as V, Left as W, type XmlDeclarationAttributes as X, Right as Y, left as Z, right as _, type ReadCertificateResponse as a, type Decimal as a0, CanonicalizationMethod$1 as b, SignatureMethod$1 as c, SignatureAlgorithm as d, DigestAlgorithm as e, StateCodes as f, StateAcronyms as g, type StateCode as h, type StateAcronym as i, type EnvironmentCode as j, type SignedInfo as k, type Signature as l, type Client as m, type SendTransmissionPayload as n, type ExtractReturnType as o, type TransmitterOptions as p, type Transmitter as q, defaultCanonicalizeOptions as r, type CanonicalizeOptions as s, defaultBuilderOptions as t, type RenderOptions as u, defaultParserOptions as v, type XmlToolkit as w, NFeTsError as x, type CacheAdapter as y, type CertificateRepository as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nfets",
-  "version": "0.0.16",
+  "version": "0.0.18",
   "description": "typescript libraries for Brazilian's SEFAZ standards",
   "type": "module",
   "main": "dist/index.mjs",
@@ -57,9 +57,7 @@
     "dotenv": "^17.2.2",
     "pdfkit": "^0.17.2",
     "reflect-metadata": "^0.2.2",
-    "rimraf": "^6.0.1",
-    "@nfets/core": "0.0.1",
-    "@nfets/nfe": "0.0.1"
+    "rimraf": "^6.0.1"
   },
   "devDependencies": {
     "@eslint/js": "^9.18.0",
@@ -75,7 +73,7 @@
     "fs-extra": "^11.3.0",
     "globals": "^16.0.0",
     "jest": "^30.2.0",
-    "node-gyp": "^11.1.0",
+    "node-gyp": "^12.1.0",
     "pdf-parse": "^2.4.5",
     "ts-jest": "^29.2.5",
     "ts-node": "^10.9.2",
@@ -88,9 +86,7 @@
     "typescript": "^5.0.0"
   },
   "scripts": {
-    "install": "node-gyp rebuild && make build",
-    "build:nfets": "tsup --config tsup.config.ts",
-    "build": "pnpm --filter @nfets/core build && pnpm --filter !@nfets/core build",
+    "build": "node-gyp rebuild && pnpm --filter !@nfets/test build && tsup --config tsup.config.ts",
     "test": "pnpm --filter @nfets/* test",
     "typecheck": "pnpm --filter @nfets/* typecheck",
     "test:coverage": "pnpm --filter @nfets/* test:coverage --coverageReporters=\"json-summary\""