xml-fiesta-types 1.8.0

package/asn1hex.d.ts

@@ -0,0 +1,8 @@
+export declare const ASN1HEX: {
+    isASN1HEX(hex: string): boolean;
+    getPosArrayOfChildren_AtObj(hex: string, pos: number): number[];
+    getHexOfTLV_AtObj(hex: string, pos: number): string;
+    getHexOfV_AtObj(hex: string, pos: number): string;
+    getDecendantHexTLVByNthList(hex: string, pos: number, nthList: number[]): string;
+    getDecendantHexVByNthList(hex: string, pos: number, nthList: number[]): string;
+};

package/certificate.d.ts

@@ -0,0 +1,33 @@
+import * as forge from "node-forge";
+export default class Certificate {
+    binaryString: string | null;
+    pem: string;
+    certificate: forge.pki.Certificate;
+    subject: Record<string, string>;
+    hex: string;
+    pubKey: forge.pki.rsa.PublicKey | null;
+    constructor(binaryString: string | null, hexString?: string);
+    toBinaryString(): string;
+    toHex(): string;
+    toPem(): string;
+    getX509(): forge.pki.Certificate;
+    getSerialNumberHex(): string;
+    getSerialNumber(): string;
+    getSubject(): Record<string, string>;
+    email(): string;
+    owner(): string;
+    owner_id(): string;
+    getUniqueIdentifier(): string[];
+    getRSAPublicKey(): forge.pki.rsa.PublicKey;
+    verifyString(string: string, signedHexString: string, alg?: string): boolean;
+    verifyHexString(hexString: string, signedHexString: string, alg?: string): boolean;
+    getUniqueIdentifierString(joinVal: any): string;
+    hasExpired(): boolean;
+    isValidOn(date: any): boolean;
+    algorithm(): string;
+    tbsCertificate(): string;
+    signature(): string;
+    isCa(rootCaHex: any): boolean;
+    validParent(rootCaPem: any, rootCaHex?: any): boolean;
+    private buildSubjectObject;
+}

package/common.d.ts

@@ -0,0 +1,9 @@
+declare function extend(object: any, properties: any): any;
+declare function b64toHex(b64String: any): string;
+declare function hextoB64(hexString: any): string;
+declare function hextoAscii(hexString: any): string;
+declare function b64toAscii(b64String: any): string;
+declare function parseDate(date: any): Date;
+declare function sha256(string: any): string;
+declare function sha256hex(hex: any): string;
+export { extend, b64toHex, hextoB64, hextoAscii, b64toAscii, parseDate, sha256, sha256hex, };

package/conservancyRecord.d.ts

@@ -0,0 +1,26 @@
+import Certificate from "./certificate";
+export default class ConservancyRecord {
+    caCert: string;
+    userCert: string;
+    record: string;
+    timestamp: string;
+    signedHash: string;
+    caCertificate: Certificate;
+    userCertificate: Certificate;
+    recordHex: string;
+    positions: any;
+    constructor(caCert: string, userCert: string, record: string, timestamp: string, signedHash: string);
+    caName(): string;
+    userName(): string;
+    timestampHex(): string;
+    archiveHex(): string;
+    archiveSignature(): string;
+    archiveSignedHash(): string;
+    validArchiveHash(): boolean;
+    recordTimestamp(): Date;
+    equalTimestamps(): boolean;
+    signedData(): string;
+    signature(): string;
+    valid(): boolean;
+    validParent(caPemCert: any): boolean;
+}

package/conservancyRecordNom2016.d.ts

@@ -0,0 +1,31 @@
+import Certificate from "./certificate";
+export default class ConservancyRecordNom2016 {
+    caCert: string;
+    record: string;
+    timestamp: any;
+    signedHash: string;
+    recordHex: string;
+    rootCertificate: Certificate;
+    tsaCertificate: Certificate;
+    private positions;
+    constructor(caCert: string, record: string, timestamp?: any, signedHash?: string);
+    rootCertificateHex(): string;
+    caCertificateHex(): string;
+    certificatesHex(): string;
+    caName(): string;
+    rootName(): string;
+    messageDigest(): string;
+    signedTimeStamp(): Date;
+    signingCertificateV2(): string;
+    tSTInfoHex(): string;
+    contentAttributesHex(): string;
+    signedAttributesHex(): string;
+    archiveHex(): string;
+    archiveSignature(): string;
+    archiveSignedHash(): string;
+    validArchiveHash(): boolean;
+    recordTimestamp(): Date;
+    equalTimestamps(): boolean;
+    valid(): boolean;
+    validParent(caPemCert: any): boolean;
+}

package/declare-module.d.ts

@@ -0,0 +1,3 @@
+declare module 'xml-fiesta' {
+  export * from './xml-fiesta';
+}

package/document.d.ts

@@ -0,0 +1,90 @@
+/// <reference types="node" />
+import ConservancyRecord from "./conservancyRecord";
+import ConservancyRecordNom2016 from "./conservancyRecordNom2016";
+import XML from "./patches/xmlPatch";
+import { Network } from "./services/blockchain";
+import { GetBlockchainTrackResult } from "./services/blockchain/liquid";
+import { ValidateOptions, ValidateResult } from "./validations/types";
+import Transfer from "./transfer";
+export declare type AssetValidation = {
+    isValid: boolean;
+    error_code?: "integrity" | "inconsistent_with_blockchain" | "not_found";
+};
+export interface FromXMLResponse {
+    document: Document;
+    xmljs: any;
+    xmlOriginalHash: string;
+    xmlHash: string;
+    xml: XML;
+    validate: (options: ValidateOptions) => Promise<ValidateResult>;
+}
+export default class Document {
+    pdf_content: string;
+    signers: any;
+    errors: any;
+    conservancyRecord: ConservancyRecord | ConservancyRecordNom2016;
+    recordPresent: boolean;
+    contentType: string;
+    name: string;
+    version: string;
+    encrypted: boolean;
+    transfersXml: any;
+    originalHash: string;
+    originalXmlHash: string;
+    tracked: boolean;
+    destroyed: boolean;
+    blockchainTrack: GetBlockchainTrackResult;
+    blockchainBinding: any;
+    currentHolder: any;
+    prevHolder: any;
+    assetId: string;
+    network: Network;
+    electronicDocument: any;
+    constructor(file: any, options: any);
+    setConservancyRecord(data: any): void;
+    fileBuffer(): Buffer;
+    pdfBuffer(): Buffer;
+    file(format: any): string;
+    setFile(file: string): void;
+    toXML(eDocument: any): any;
+    pdf(format: any): string;
+    addSigner(signer: any): any;
+    signatures(): any;
+    validSignatures(): boolean;
+    transfers(): Promise<Transfer[]>;
+    isSimpleTrackedDocument(rootCertificates: any): any;
+    isValidHashInTrackedDocument(rootCertificates: any): {
+        isValid: boolean;
+        error_code: string;
+    } | {
+        isValid: boolean;
+        error_code?: undefined;
+    };
+    validHashInBlockchainBinding(rootCertificates: any, hash: string): boolean;
+    getStatusTrackedDocument(rootCertificates: any): "error" | "updated" | "not_updated";
+    isValidAssetId(rootCertificates: any): AssetValidation;
+    static getOptsToInitializeDocument: ({ xml, prevHolder, useTestnet, isOriginalDocument, }: {
+        xml: any;
+        prevHolder?: any;
+        useTestnet?: boolean;
+        isOriginalDocument?: boolean;
+    }) => Promise<{
+        electronicDocument: any;
+        signers: any;
+        version: any;
+        name: any;
+        encrypted: any;
+        contentType: any;
+        conservancyRecord: any;
+        blockchainTrack: any;
+        tracked: any;
+        destroyed: boolean;
+        transfersXml: any;
+        blockchainBinding: any;
+        currentHolder: any;
+        prevHolder: any;
+        assetId: any;
+        network: any;
+    }>;
+    static fromXml(xmlString: any, useTestnet?: boolean): Promise<FromXMLResponse>;
+}

package/errors.d.ts

@@ -0,0 +1,12 @@
+export declare class InvalidSignerError extends Error {
+    constructor(...args: any[]);
+}
+export declare class CertificateError extends Error {
+    constructor(...args: any[]);
+}
+export declare class ArgumentError extends Error {
+    constructor(...args: any[]);
+}
+export declare class InvalidRecordError extends Error {
+    constructor(...args: any[]);
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "xml-fiesta-types",
+  "version": "1.8.0",
+  "description": "TypeScript definitions for xml-fiesta",
+  "types": "declare-module.d.ts",
+  "files": [
+    "**/*.d.ts"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Mifiel/xml-fiesta-js.git"
+  },
+  "keywords": [
+    "xml-fiesta",
+    "typescript",
+    "types"
+  ],
+  "author": "Jesús López <alejandro@mifiel.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/Mifiel/xml-fiesta-js/issues"
+  },
+  "homepage": "https://github.com/Mifiel/xml-fiesta-js#readme"
+}

package/patches/xmlPatch.d.ts

@@ -0,0 +1,4 @@
+import XML from "../xml";
+export default class PatchedXML extends XML {
+    static removeGeolocation(xmljs: any): void;
+}

package/services/blockchain/index.d.ts

@@ -0,0 +1,5 @@
+import Liquid from "./liquid";
+export declare type Network = "LBTC" | "LTC";
+export declare class Blockchain {
+    static init: (network: Network) => Liquid;
+}

package/services/blockchain/liquid.d.ts

@@ -0,0 +1,27 @@
+declare type GetTxDataResult = {
+    index: number;
+    address: string;
+};
+declare type GetTxOutspentsResult = {
+    spent: boolean;
+    txid: string;
+};
+export declare type GetTransfersByTxIdResult = {
+    prevTxid: string;
+    txid: string;
+    prevAddress: string;
+    currentAddress: string;
+};
+export declare type GetBlockchainTrackResult = {
+    asset: string;
+    transfers: GetTransfersByTxIdResult[];
+};
+export default class Liquid {
+    private BASE_URL;
+    useTestnet(): void;
+    getTxData: (txid: string, asset: string) => Promise<GetTxDataResult>;
+    getTxtOutspents: (txid: string) => Promise<GetTxOutspentsResult[]>;
+    getTransfersByTxId: (asset: string, txid: string, prevAddress?: string, prevTxid?: string) => Promise<GetTransfersByTxIdResult[]>;
+    getBlockchainTrack: (asset: string) => Promise<GetBlockchainTrackResult>;
+}
+export {};

package/signature.d.ts

@@ -0,0 +1,18 @@
+import Certificate from "./certificate";
+export default class Signature {
+    signature: string;
+    ePassInfo: any;
+    ePassContent: string;
+    signedAt: string;
+    email: string;
+    certificate: Certificate;
+    signer: {
+        id: string;
+        name: string;
+        email: string;
+    };
+    constructor(cer: any, signature: any, signedAt: any, email: any, ePassInfo: any, name?: string);
+    ePass(format: any): string;
+    sig(format: any): string;
+    valid(hash: any): boolean;
+}

package/transfer.d.ts

@@ -0,0 +1,13 @@
+import Document, { AssetValidation } from "./document";
+import { GetTransfersByTxIdResult } from "./services/blockchain/liquid";
+import XML from "./xml";
+export default class Transfer extends Document {
+    prevAddress: string;
+    currentAddress: string;
+    dataBlockchain: GetTransfersByTxIdResult;
+    xml: XML;
+    constructor(xml: any, options: any, transferData: any);
+    validEndorser(rootCertificates: any): AssetValidation;
+    validEndorsee(rootCertificates: any): AssetValidation;
+    validateHolderBinding(holder: any, rootCertificates: any): boolean;
+}

package/validations/endorsement/validate-tracked-xml.d.ts

@@ -0,0 +1,3 @@
+import { RootCertificate, TrackedValidationResult } from "../types";
+import { ParsedInstanceLike } from "../validate";
+export declare const validateTrackedXml: (instance: ParsedInstanceLike, rootCertificates: RootCertificate[]) => Promise<TrackedValidationResult>;

package/validations/endorsement/validate-transfers.d.ts

@@ -0,0 +1,3 @@
+import { RootCertificate, TransferValidationResult } from "../types";
+import { ParsedInstanceLike } from "../validate";
+export declare const validateTransfers: (instance: ParsedInstanceLike, rootCertificates: RootCertificate[]) => Promise<TransferValidationResult[]>;

package/validations/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./types";
+export * from "./validate";
+export * from "./standard/validate-document";
+export * from "./standard/validate-signatures";
+export * from "./standard/validate-standard-xml";
+export * from "./endorsement/validate-tracked-xml";
+export * from "./endorsement/validate-transfers";

package/validations/standard/validate-document.d.ts

@@ -0,0 +1,3 @@
+import { DocumentValidationResult } from "../types";
+import { ParsedInstanceLike } from "../validate";
+export declare const validateDocument: (instance: ParsedInstanceLike) => Promise<DocumentValidationResult>;

package/validations/standard/validate-signatures.d.ts

@@ -0,0 +1,3 @@
+import { RootCertificate, SignatureValidationResult } from "../types";
+import Document from "../../document";
+export declare const validateSignatures: (document: Document, rootCertificates: RootCertificate[]) => SignatureValidationResult[];

package/validations/standard/validate-standard-xml.d.ts

@@ -0,0 +1,3 @@
+import { RootCertificate, StandardValidationResult } from "../types";
+import { ParsedInstanceLike } from "../validate";
+export declare const validateStandardXml: (instance: ParsedInstanceLike, rootCertificates: RootCertificate[]) => Promise<StandardValidationResult>;

package/validations/types.d.ts

@@ -0,0 +1,56 @@
+import Transfer from "../transfer";
+import Document from "../document";
+import Signature from "../signature";
+import { AssetValidation } from "../document";
+export declare type RootCertificate = {
+    cer_hex: string;
+};
+export declare type SignatureValidationResult = {
+    certificateNumber: string;
+    certificateNumberIsValid: boolean;
+    fielIsValid: boolean;
+    isValid: boolean;
+    metadata: Signature;
+};
+export declare type DocumentValidationResult = {
+    isValid: boolean;
+    oHashValid: boolean;
+    conservancyRecordPresent: boolean;
+    timestampsMatch: boolean;
+    archiveHashValid: boolean;
+    metadata: Document;
+};
+export declare type StandardValidationResult = {
+    isValid: boolean;
+    document: DocumentValidationResult;
+    signatures: SignatureValidationResult[];
+};
+export declare type TransferValidationResult = {
+    transferIsValid: boolean;
+    transfer: Transfer;
+    endorser: AssetValidation;
+    endorsee: AssetValidation;
+    document: DocumentValidationResult;
+    signatures: SignatureValidationResult[];
+};
+export declare type TrackedValidationResult = {
+    isValid: boolean;
+    showLimitData: boolean;
+    oHashValid: boolean;
+    asset: AssetValidation;
+    document: DocumentValidationResult;
+    signatures: SignatureValidationResult[];
+    transfers?: TransferValidationResult[];
+};
+export declare type ValidateOptions = {
+    rootCertificates: RootCertificate[];
+};
+export declare type ValidateResult = {
+    mode: "standard";
+    isValid: boolean;
+    standard: StandardValidationResult;
+} | {
+    mode: "tracked";
+    isValid: boolean;
+    tracked: TrackedValidationResult;
+};

package/validations/validate.d.ts

@@ -0,0 +1,9 @@
+import { ValidateOptions, ValidateResult } from "./types";
+import Document from "../document";
+import XML from "../xml";
+export declare type ParsedInstanceLike = {
+    xml?: XML;
+    document: Document;
+    xmlOriginalHash?: string;
+};
+export declare const validateParsedXml: (parsed: ParsedInstanceLike, options: ValidateOptions) => Promise<ValidateResult>;

package/xml-fiesta.d.ts

@@ -0,0 +1,16 @@
+import Certificate from "./certificate";
+import Document from "./document";
+import Signature from "./signature";
+import ConservancyRecord from "./conservancyRecord";
+import ConservancyRecordNom2016 from "./conservancyRecordNom2016";
+import XML from "./xml";
+import * as validations from "./validations";
+import { InvalidSignerError, CertificateError, ArgumentError, InvalidRecordError } from "./errors";
+declare const version: any;
+declare const errors: {
+    InvalidSignerError: typeof InvalidSignerError;
+    CertificateError: typeof CertificateError;
+    ArgumentError: typeof ArgumentError;
+    InvalidRecordError: typeof InvalidRecordError;
+};
+export { Certificate, Document, Signature, ConservancyRecord, ConservancyRecordNom2016, XML, validations, errors, version, };

package/xml.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="node" />
+export default class XML {
+    eDocument: any;
+    signed: boolean;
+    version: any;
+    version_int: any;
+    fileElementName: any;
+    encrypted: any;
+    name: any;
+    contentType: any;
+    originalHash: any;
+    tracked: boolean;
+    destroyed: boolean;
+    nameSpaces: any;
+    static parse(string: any): Promise<XML>;
+    static parseByElectronicDocument(electronicDocument: any): XML;
+    static toXML(eDocument: any, file: string): any;
+    static removeEncrypedData(xmljs: any): void;
+    static removeGeolocation(xmljs: any): void;
+    static removeBlockchain(xmljs: any): void;
+    static removeTransfer(xmljs: any): void;
+    static detectNamespacePrefix(xmlString: string): string | null;
+    static createAttrNameStripper(xmlString: string): (name: string) => string;
+    static removeSignersCertificate(xmljs: any): void;
+    parseByElectronicDocument(electronicDocument: any): XML;
+    parse(xml: any): Promise<XML>;
+    canonical(electronicDocumentAttributes?: {}): any;
+    getCanonicalBuffer(electronicDocumentAttributes: any): Buffer;
+    file(): any;
+    pdf(): any;
+    xmlSigners(): any[];
+    getConservancyRecord(): {
+        caCert: any;
+        userCert: any;
+        record: any;
+        timestamp: any;
+        originalXmlHash: string;
+        version: any;
+    };
+}