cas-typescript-sdk 1.0.22 → 1.0.23

package/README.md

@@ -2,23 +2,25 @@
 
 [![image](https://img.shields.io/badge/Discord-5865F2?style=for-the-badge&logo=discord&logoColor=white)](https://discord.gg/7bXXCQj45q)
 
-Ever wanted all of your most useful cryptographic operations in one module and not have to surf documentation for various packages? 
+Ever wanted all of your most useful cryptographic operations in one module and not had to surf documentation for various packages? 
 CAS is here to provide a unified development experience as an abstract layer to the RustCrypto and Dalek-Cryptography suite of algorithms.
 The official NPM page can be found [here](https://www.npmjs.com/package/cas-typescript-sdk).
 
-## [Examples](./docs/EXAMPLES.md)
-
-## Consuming Library Documentation
 **Note: All work is experimental and we understand some benchmarks might not be the most optimal.**
 
-This Node.js NPM module is dependent on our Rust layer [here](./src) that contains methods to run industry standard cryptographic operations sequentially, on threads, and the thread pool.
+
+
 
 ## Consuming Library Documentation
+This Node.js NPM module is dependent on our Rust layer [here](./src) that contains methods to run industry-standard cryptographic operations sequentially, on threads, and the thread pool.
+
 We utilize some smart people's existing work and we believe their documentation should be reviewed when possible.
 - [Spin Research](https://github.com/SpinResearch)
 - [Dalek-Cryptography](https://github.com/dalek-cryptography)
 - [Rust Crypto](https://github.com/RustCrypto)
 - [Rayon](https://github.com/rayon-rs/rayon)
 
+## [Examples](./docs/EXAMPLES.md)
+
 ## Disclaimer
 Many of the cryptographic crates that are utilized in our core FFI [layer](./src) have never had a security audit performed. Utilize this SDK at your own risk.

package/lib/asymmetric/RSAWrapper.d.ts

@@ -1,8 +1,38 @@
 import { RsaKeyPairResult } from "../../index";
 export declare class RSAWrapper {
+    /**
+     * Generates an RSA key pair based of parameter sent in 1024, 2048, and 4096 are supported.
+     * @param keySize
+     * @returns RsaKeyPairResult
+     */
     generateKeys(keySize: number): RsaKeyPairResult;
+    /**
+     * Encrypts a plaintext byte array with a RSA public key
+     * @param publicKey
+     * @param plaintext
+     * @returns Array<number>
+     */
     encrypt(publicKey: string, plaintext: Array<number>): Array<number>;
+    /**
+     * Decrypts a ciphertext with an RSA private key.
+     * @param privateKey
+     * @param ciphertext
+     * @returns Array<number>
+     */
     decrypt(privateKey: string, ciphertext: Array<number>): Array<number>;
-    sign(privateKey: string, hash: Array<number>): Array<number>;
+    /**
+     * Signs a byte array with an RSA private key for verification.
+     * @param privateKey
+     * @param hash
+     * @returns Array<number>
+     */
+    sign(privateKey: string, dataToSign: Array<number>): Array<number>;
+    /**
+     * Verifies signed data by the corresponding private key with an RSA public key.
+     * @param publicKey
+     * @param hash
+     * @param signature
+     * @returns boolean
+     */
     verify(publicKey: string, hash: Array<number>, signature: Array<number>): boolean;
 }

package/lib/asymmetric/RSAWrapper.js

@@ -3,12 +3,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RSAWrapper = void 0;
 const index_1 = require("../../index");
 class RSAWrapper {
+    /**
+     * Generates an RSA key pair based of parameter sent in 1024, 2048, and 4096 are supported.
+     * @param keySize
+     * @returns RsaKeyPairResult
+     */
     generateKeys(keySize) {
         if (keySize !== 1024 && keySize !== 2048 && keySize !== 4096) {
             throw new Error("You must provide an appropriate key size to generate RSA keys");
         }
         return (0, index_1.generateRsaKeys)(keySize);
     }
+    /**
+     * Encrypts a plaintext byte array with a RSA public key
+     * @param publicKey
+     * @param plaintext
+     * @returns Array<number>
+     */
     encrypt(publicKey, plaintext) {
         if (!publicKey) {
             throw new Error("You must provide a public key to encrypt with RSA");
@@ -18,6 +29,12 @@ class RSAWrapper {
         }
         return (0, index_1.encryptPlaintextRsa)(publicKey, plaintext);
     }
+    /**
+     * Decrypts a ciphertext with an RSA private key.
+     * @param privateKey
+     * @param ciphertext
+     * @returns Array<number>
+     */
     decrypt(privateKey, ciphertext) {
         if (!privateKey) {
             throw new Error("You must provide a private key to encrypt with RSA");
@@ -27,15 +44,28 @@ class RSAWrapper {
         }
         return (0, index_1.decryptCiphertextRsa)(privateKey, ciphertext);
     }
-    sign(privateKey, hash) {
+    /**
+     * Signs a byte array with an RSA private key for verification.
+     * @param privateKey
+     * @param hash
+     * @returns Array<number>
+     */
+    sign(privateKey, dataToSign) {
         if (!privateKey) {
             throw new Error("You must provide a private key to sign with RSA");
         }
-        if (!hash || hash.length === 0) {
+        if (!dataToSign || dataToSign.length === 0) {
             throw new Error("You must provide an allocated hash to sign with RSA");
         }
-        return (0, index_1.signRsa)(privateKey, hash);
+        return (0, index_1.signRsa)(privateKey, dataToSign);
     }
+    /**
+     * Verifies signed data by the corresponding private key with an RSA public key.
+     * @param publicKey
+     * @param hash
+     * @param signature
+     * @returns boolean
+     */
     verify(publicKey, hash, signature) {
         if (!publicKey) {
             throw new Error("You must provide a public key to verify with RSA");

package/lib/digital-signature/digital-siganture-sha-512.d.ts

@@ -1,8 +1,33 @@
 import { RsaDigitalSignatureResult, SHAED25519DalekDigitalSignatureResult } from "../../index";
 import { IDigitalSignature } from "./digital-signature-base";
 export declare class DigitalSignatureSHA512Wrapper implements IDigitalSignature {
+    /**
+     * Creates an ED25519 siganture from an array of bytes with SHA3-512.
+     * @param dataToSign
+     * @returns SHAED25519DalekDigitalSignatureResult
+     */
     createED25519(dataToSign: number[]): SHAED25519DalekDigitalSignatureResult;
+    /**
+     * Verifies an ED25519 signature with the public key generated from running createED25519() with SHA3-512
+     * @param publicKey
+     * @param dataToVerify
+     * @param signature
+     * @returns boolean
+     */
     verifyED25519(publicKey: number[], dataToVerify: number[], signature: number[]): boolean;
+    /**
+     * Generates and RSA digital signature with SHA3-512
+     * @param rsa_key_size
+     * @param data_to_sign
+     * @returns RsaDigitalSignatureResult
+     */
     createRsa(rsa_key_size: number, data_to_sign: number[]): RsaDigitalSignatureResult;
+    /**
+     * Verifies a digital signature created with the RSA public key.
+     * @param public_key
+     * @param data_to_verify
+     * @param signature
+     * @returns boolean
+     */
     verifyRSa(public_key: string, data_to_verify: number[], signature: number[]): boolean;
 }

package/lib/digital-signature/digital-siganture-sha-512.js

@@ -3,12 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DigitalSignatureSHA512Wrapper = void 0;
 const index_1 = require("../../index");
 class DigitalSignatureSHA512Wrapper {
+    /**
+     * Creates an ED25519 siganture from an array of bytes with SHA3-512.
+     * @param dataToSign
+     * @returns SHAED25519DalekDigitalSignatureResult
+     */
     createED25519(dataToSign) {
         if (dataToSign?.length === 0) {
             throw new Error("Must provide allocated data to sign");
         }
         return (0, index_1.sha512Ed25519DigitalSignature)(dataToSign);
     }
+    /**
+     * Verifies an ED25519 signature with the public key generated from running createED25519() with SHA3-512
+     * @param publicKey
+     * @param dataToVerify
+     * @param signature
+     * @returns boolean
+     */
     verifyED25519(publicKey, dataToVerify, signature) {
         if (!publicKey) {
             throw new Error("You must provide a public key for verify with ED25519");
@@ -21,6 +33,12 @@ class DigitalSignatureSHA512Wrapper {
         }
         return (0, index_1.sha512Ed25519DigitalSignatureVerify)(publicKey, dataToVerify, signature);
     }
+    /**
+     * Generates and RSA digital signature with SHA3-512
+     * @param rsa_key_size
+     * @param data_to_sign
+     * @returns RsaDigitalSignatureResult
+     */
     createRsa(rsa_key_size, data_to_sign) {
         if (rsa_key_size !== 1024 && rsa_key_size !== 2048 && rsa_key_size !== 4096) {
             throw new Error("You need to provide an appropriate RSA key size.");
@@ -30,6 +48,13 @@ class DigitalSignatureSHA512Wrapper {
         }
         return (0, index_1.sha512RsaDigitalSignature)(rsa_key_size, data_to_sign);
     }
+    /**
+     * Verifies a digital signature created with the RSA public key.
+     * @param public_key
+     * @param data_to_verify
+     * @param signature
+     * @returns boolean
+     */
     verifyRSa(public_key, data_to_verify, signature) {
         if (!public_key) {
             throw new Error("Must provide a public key");

package/lib/digital-signature/digital-signature-factory.d.ts

@@ -4,5 +4,10 @@ export declare enum DigitalSignatureType {
     SHA256 = 2
 }
 export declare class DigitalSignatureFactory {
+    /**
+     * Get the appropriate digital signature wrapper based upon the type passed in.
+     * @param type
+     * @returns
+     */
     static get(type: DigitalSignatureType): DigitalSignatureSHA512Wrapper;
 }

package/lib/digital-signature/digital-signature-factory.js

@@ -9,6 +9,11 @@ var DigitalSignatureType;
     DigitalSignatureType[DigitalSignatureType["SHA256"] = 2] = "SHA256";
 })(DigitalSignatureType || (exports.DigitalSignatureType = DigitalSignatureType = {}));
 class DigitalSignatureFactory {
+    /**
+     * Get the appropriate digital signature wrapper based upon the type passed in.
+     * @param type
+     * @returns
+     */
     static get(type) {
         let ds = new digital_siganture_sha_512_1.DigitalSignatureSHA512Wrapper();
         switch (type) {

package/lib/digital-signature/digital-signaturte-sha-256.d.ts

@@ -1,8 +1,33 @@
 import { RsaDigitalSignatureResult, Shaed25519DalekDigitalSignatureResult } from "../../index";
 import { IDigitalSignature } from "./digital-signature-base";
 export declare class DigitalSignatureSHA256Wrapper implements IDigitalSignature {
+    /**
+     * Creates an ED25519 siganture from an array of bytes with SHA3-512.
+     * @param dataToSign
+     * @returns SHAED25519DalekDigitalSignatureResult
+     */
     createED25519(dataToSign: number[]): Shaed25519DalekDigitalSignatureResult;
+    /**
+     * Verifies an ED25519 signature with the public key generated from running createED25519() with SHA3-512
+     * @param publicKey
+     * @param dataToVerify
+     * @param signature
+     * @returns boolean
+     */
     verifyED25519(publicKey: number[], dataToVerify: number[], signature: number[]): boolean;
+    /**
+     * Generates and RSA digital signature with SHA3-512
+     * @param rsa_key_size
+     * @param data_to_sign
+     * @returns RsaDigitalSignatureResult
+     */
     createRsa(rsa_key_size: number, data_to_sign: number[]): RsaDigitalSignatureResult;
+    /**
+     * Verifies a digital signature created with the RSA public key.
+     * @param public_key
+     * @param data_to_verify
+     * @param signature
+     * @returns boolean
+     */
     verifyRSa(public_key: string, data_to_verify: number[], signature: number[]): boolean;
 }

package/lib/digital-signature/digital-signaturte-sha-256.js

@@ -3,12 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DigitalSignatureSHA256Wrapper = void 0;
 const index_1 = require("../../index");
 class DigitalSignatureSHA256Wrapper {
+    /**
+     * Creates an ED25519 siganture from an array of bytes with SHA3-512.
+     * @param dataToSign
+     * @returns SHAED25519DalekDigitalSignatureResult
+     */
     createED25519(dataToSign) {
         if (dataToSign?.length === 0) {
             throw new Error("Must provide allocated data to sign");
         }
         return (0, index_1.sha256Ed25519DigitalSignature)(dataToSign);
     }
+    /**
+     * Verifies an ED25519 signature with the public key generated from running createED25519() with SHA3-512
+     * @param publicKey
+     * @param dataToVerify
+     * @param signature
+     * @returns boolean
+     */
     verifyED25519(publicKey, dataToVerify, signature) {
         if (!publicKey) {
             throw new Error("You must provide a public key for verify with ED25519");
@@ -21,6 +33,12 @@ class DigitalSignatureSHA256Wrapper {
         }
         return (0, index_1.sha256Ed25519DigitalSignatureVerify)(publicKey, dataToVerify, signature);
     }
+    /**
+     * Generates and RSA digital signature with SHA3-512
+     * @param rsa_key_size
+     * @param data_to_sign
+     * @returns RsaDigitalSignatureResult
+     */
     createRsa(rsa_key_size, data_to_sign) {
         if (rsa_key_size !== 1024 && rsa_key_size !== 2048 && rsa_key_size !== 4096) {
             throw new Error("You need to provide an appropriate RSA key size.");
@@ -30,6 +48,13 @@ class DigitalSignatureSHA256Wrapper {
         }
         return (0, index_1.sha256RsaDigitalSignature)(rsa_key_size, data_to_sign);
     }
+    /**
+     * Verifies a digital signature created with the RSA public key.
+     * @param public_key
+     * @param data_to_verify
+     * @param signature
+     * @returns boolean
+     */
     verifyRSa(public_key, data_to_verify, signature) {
         if (!public_key) {
             throw new Error("Must provide a public key");

package/lib/hashers/hasher-factory.d.ts

@@ -1,4 +1,9 @@
 import { HasherType } from "./hasher-type";
 export declare class HasherFactory {
+    /**
+     * Get the appropriate hasher wrapper based upon the type based in.
+     * @param type
+     * @returns
+     */
     getHasher(type: HasherType): any;
 }

package/lib/hashers/hasher-factory.js

@@ -3,6 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HasherFactory = void 0;
 const sha_wrapper_1 = require("./sha-wrapper");
 class HasherFactory {
+    /**
+     * Get the appropriate hasher wrapper based upon the type based in.
+     * @param type
+     * @returns
+     */
     getHasher(type) {
         let result = new sha_wrapper_1.SHAWrapper();
         switch (type) {

package/lib/hashers/sha-wrapper.d.ts

@@ -1,7 +1,29 @@
 import { IHasherBase } from "./hasher-base";
 export declare class SHAWrapper implements IHasherBase {
+    /**
+     * Hashes a byte array with SHA3-512.
+     * @param dataToHash
+     * @returns number[]
+     */
     hash512(dataToHash: number[]): number[];
+    /**
+     * Verifies unsigned data against an SHA3-512 hash.
+     * @param dataToHash
+     * @param dataToVerify
+     * @returns boolean
+     */
     verify512(dataToHash: number[], dataToVerify: number[]): boolean;
+    /**
+     * Hashes a byte array with SHA3-256.
+     * @param dataToHash
+     * @returns number[]
+     */
     hash256(dataToHash: number[]): number[];
+    /**
+     * Verifies unsigned data against an SHA3-256 hash.
+     * @param dataToHash
+     * @param dataToVerify
+     * @returns boolean
+     */
     verify256(dataToHash: number[], dataToVerify: number[]): boolean;
 }

package/lib/hashers/sha-wrapper.js

@@ -3,12 +3,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SHAWrapper = void 0;
 const index_1 = require("../../index");
 class SHAWrapper {
+    /**
+     * Hashes a byte array with SHA3-512.
+     * @param dataToHash
+     * @returns number[]
+     */
     hash512(dataToHash) {
         if (!dataToHash || dataToHash.length === 0) {
             throw new Error("You must provide an allocated array of data");
         }
         return (0, index_1.sha512)(dataToHash);
     }
+    /**
+     * Verifies unsigned data against an SHA3-512 hash.
+     * @param dataToHash
+     * @param dataToVerify
+     * @returns boolean
+     */
     verify512(dataToHash, dataToVerify) {
         if (!dataToHash || dataToHash.length === 0) {
             throw new Error("You must provide an allocated array of data");
@@ -18,12 +29,23 @@ class SHAWrapper {
         }
         return (0, index_1.sha512Verify)(dataToHash, dataToVerify);
     }
+    /**
+     * Hashes a byte array with SHA3-256.
+     * @param dataToHash
+     * @returns number[]
+     */
     hash256(dataToHash) {
         if (!dataToHash || dataToHash.length === 0) {
             throw new Error("You must provide an allocated array of data");
         }
         return (0, index_1.sha256)(dataToHash);
     }
+    /**
+     * Verifies unsigned data against an SHA3-256 hash.
+     * @param dataToHash
+     * @param dataToVerify
+     * @returns boolean
+     */
     verify256(dataToHash, dataToVerify) {
         if (!dataToHash || dataToHash.length === 0) {
             throw new Error("You must provide an allocated array of data");

package/lib/hybrid/hybrid-encryption-wrapper.d.ts

@@ -4,6 +4,18 @@ export declare class HybridEncryptionWrapper {
     private aesWrapper;
     private rsaWrapper;
     constructor();
+    /**
+     * Encrypts data with RSA/AES hybrid encryption. The data is encrypted with AES-GCM and the AES key is encrypted with the RSA public key.
+     * @param dataToEncrypt
+     * @param initalizer
+     * @returns AesRsaHybridEncryptResult
+     */
     encrypt(dataToEncrypt: Array<number>, initalizer: AESRSAHybridInitializer): AesRsaHybridEncryptResult;
+    /**
+     * Decrypts data with RSA/AES hybrid encryption. The RSA private key decrypts the AES key and then the data is decrypted with AES-GCM.
+     * @param dataToEncrypt
+     * @param initalizer
+     * @returns AesRsaHybridEncryptResult
+     */
     decrypt(privateKey: string, encryptResult: AesRsaHybridEncryptResult): Array<number>;
 }

package/lib/hybrid/hybrid-encryption-wrapper.js

@@ -11,6 +11,12 @@ class HybridEncryptionWrapper {
         this.aesWrapper = new symmetric_1.AESWrapper();
         this.rsaWrapper = new asymmetric_1.RSAWrapper();
     }
+    /**
+     * Encrypts data with RSA/AES hybrid encryption. The data is encrypted with AES-GCM and the AES key is encrypted with the RSA public key.
+     * @param dataToEncrypt
+     * @param initalizer
+     * @returns AesRsaHybridEncryptResult
+     */
     encrypt(dataToEncrypt, initalizer) {
         let encryptedData = (initalizer.aesType === 128)
             ? this.aesWrapper.aes128Encrypt(initalizer.aesKey, initalizer.aesNonce, dataToEncrypt)
@@ -19,6 +25,12 @@ class HybridEncryptionWrapper {
         let result = new aes_rsa_hybird_encrypt_result_1.AesRsaHybridEncryptResult(encryptedData, encryptedAesKey, initalizer.aesType, initalizer.aesNonce);
         return result;
     }
+    /**
+     * Decrypts data with RSA/AES hybrid encryption. The RSA private key decrypts the AES key and then the data is decrypted with AES-GCM.
+     * @param dataToEncrypt
+     * @param initalizer
+     * @returns AesRsaHybridEncryptResult
+     */
     decrypt(privateKey, encryptResult) {
         let plaintextAesKey = this.rsaWrapper.decrypt(privateKey, encryptResult.encryptedAesKey);
         let plaintext = (encryptResult.aesType === 128)

package/lib/hybrid/types/aes-rsa-hybrid-initializer.d.ts

@@ -4,5 +4,10 @@ export declare class AESRSAHybridInitializer {
     aesKey: Array<number>;
     aesNonce: Array<number>;
     rsaKeyPair: RsaKeyPairResult;
+    /**
+     * Constructs an initalizer to use with Hybrid Encryption wrapper. Generates your RSA key pair, AES nonce, and AES key based on the parameters passed in.
+     * @param aesType
+     * @param rsaSize
+     */
     constructor(aesType: number, rsaSize: number);
 }

package/lib/hybrid/types/aes-rsa-hybrid-initializer.js

@@ -8,6 +8,11 @@ class AESRSAHybridInitializer {
     aesKey;
     aesNonce;
     rsaKeyPair;
+    /**
+     * Constructs an initalizer to use with Hybrid Encryption wrapper. Generates your RSA key pair, AES nonce, and AES key based on the parameters passed in.
+     * @param aesType
+     * @param rsaSize
+     */
     constructor(aesType, rsaSize) {
         if (aesType !== 128 && aesType !== 256) {
             throw new Error("Need an appropriate AES size to generate a hybrid initalizer");

package/lib/key_exchange/x25519.d.ts

@@ -1,5 +1,17 @@
 import { X25519SecretPublicKeyResult } from "../../index";
 export declare class X25519Wrapper {
+    /**
+     * Generates and secret and public key to be used to create a shared secret with Diffie Hellman.
+     * User should share their public key with the other user and take the other user's public key and they can generate a Shared Secret.
+     * @returns X25519SecretPublicKeyResult
+     */
     generateSecretAndPublicKey(): X25519SecretPublicKeyResult;
-    generateSharedSecret(secretKey: Array<number>, publicKey: Array<number>): number[];
+    /**
+     * User takes their secret key and the other user's public key to generate a shared secret.
+     * Can be used to derive an AES key over insecure channel.
+     * @param secretKey
+     * @param publicKey
+     * @returns Array<number>
+     */
+    generateSharedSecret(secretKey: Array<number>, publicKey: Array<number>): Array<number>;
 }

package/lib/key_exchange/x25519.js

@@ -3,9 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.X25519Wrapper = void 0;
 const index_1 = require("../../index");
 class X25519Wrapper {
+    /**
+     * Generates and secret and public key to be used to create a shared secret with Diffie Hellman.
+     * User should share their public key with the other user and take the other user's public key and they can generate a Shared Secret.
+     * @returns X25519SecretPublicKeyResult
+     */
     generateSecretAndPublicKey() {
         return (0, index_1.x25519GenerateSecretAndPublicKey)();
     }
+    /**
+     * User takes their secret key and the other user's public key to generate a shared secret.
+     * Can be used to derive an AES key over insecure channel.
+     * @param secretKey
+     * @param publicKey
+     * @returns Array<number>
+     */
     generateSharedSecret(secretKey, publicKey) {
         return (0, index_1.x25519DiffieHellman)(secretKey, publicKey);
     }

package/lib/password-hashers/argon2-wrapper.d.ts

@@ -1,7 +1,29 @@
 import { IPasswordHasherBase } from "./password-hasher-base";
 export declare class Argon2Wrapper implements IPasswordHasherBase {
+    /**
+     * Verifies a password with Argon2 on the threadpool.
+     * @param hashedPassword
+     * @param passwordToCheck
+     * @returns boolean
+     */
     verifyThreadPool(hashedPassword: string, passwordToCheck: string): boolean;
+    /**
+     * Hashes a password with Argon2 on the threadpool.
+     * @param password
+     * @returns string
+     */
     hashPasswordThreadPool(password: string): string;
+    /**
+     * Hashes a password with Argon2
+     * @param password
+     * @returns string
+     */
     hashPassword(password: string): string;
+    /**
+     * Verifies that a password is the same as the hashed password with Argon2.
+     * @param hashedPassword
+     * @param passwordToVerify
+     * @returns boolean
+     */
     verify(hashedPassword: string, passwordToVerify: string): boolean;
 }

package/lib/password-hashers/argon2-wrapper.js

@@ -3,6 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Argon2Wrapper = void 0;
 const index_1 = require("./../../index");
 class Argon2Wrapper {
+    /**
+     * Verifies a password with Argon2 on the threadpool.
+     * @param hashedPassword
+     * @param passwordToCheck
+     * @returns boolean
+     */
     verifyThreadPool(hashedPassword, passwordToCheck) {
         if (!hashedPassword) {
             throw new Error("You must provide a password to verify with Argon2");
@@ -12,18 +18,34 @@ class Argon2Wrapper {
         }
         return (0, index_1.argon2VerifyThreadpool)(hashedPassword, passwordToCheck);
     }
+    /**
+     * Hashes a password with Argon2 on the threadpool.
+     * @param password
+     * @returns string
+     */
     hashPasswordThreadPool(password) {
         if (!password) {
             throw new Error("You must provide a password to hash with Argon2");
         }
         return (0, index_1.argon2HashThreadPool)(password);
     }
+    /**
+     * Hashes a password with Argon2
+     * @param password
+     * @returns string
+     */
     hashPassword(password) {
         if (!password) {
             throw new Error("You must provide a password to hash with Argon2");
         }
         return (0, index_1.argon2Hash)(password);
     }
+    /**
+     * Verifies that a password is the same as the hashed password with Argon2.
+     * @param hashedPassword
+     * @param passwordToVerify
+     * @returns boolean
+     */
     verify(hashedPassword, passwordToVerify) {
         if (!hashedPassword || !passwordToVerify) {
             throw new Error("You must provide a hashed password and a plaintext password to verify with Argon2");

package/lib/password-hashers/bcrypt-wrapper.d.ts

@@ -1,7 +1,29 @@
 import { IPasswordHasherBase } from "./password-hasher-base";
 export declare class BCryptWrapper implements IPasswordHasherBase {
+    /**
+     * Verifies a password with BCrypt on the threadpool.
+     * @param hashedPassword
+     * @param passwordToCheck
+     * @returns boolean
+     */
     verifyThreadPool(hashedPassword: string, passwordToCheck: string): boolean;
+    /**
+     * Hashes a password with BCrypt on the threadpool.
+     * @param password
+     * @returns string
+     */
     hashPasswordThreadPool(password: string): string;
+    /**
+     * Hashes a password with BCrypt
+     * @param password
+     * @returns string
+     */
     hashPassword(password: string): string;
+    /**
+     * Verifies that a password is the same as the hashed password with BCrypt.
+     * @param hashedPassword
+     * @param passwordToVerify
+     * @returns boolean
+     */
     verify(hashedPassword: string, passwordToVerify: string): boolean;
 }