@salesforce/b2c-cli 1.11.0 → 1.12.1

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/crypto/Mac.d.ts

@@ -0,0 +1,76 @@
+import Bytes = require('../util/Bytes');
+
+/**
+ * This class provides the functionality of a "Message Authentication Code" (MAC) algorithm.
+ * A MAC provides a way to check the integrity of information transmitted over or
+ * stored in an unreliable medium, based on a secret key.
+ * Typically, message authentication codes are used between two parties
+ * that share a secret key in order to validate information transmitted between these parties.
+ * A MAC mechanism that is based on cryptographic hash functions is referred to as HMAC.
+ * HMAC can be used with any cryptographic hash function, e.g., SHA256,
+ * in combination with a secret shared key. HMAC is specified in RFC 2104.
+ * 
+ * Note: this class handles sensitive security-related data.
+ * Pay special attention to PCI DSS v3. requirements 2, 4, and 12.
+ */
+declare class Mac {
+    /**
+     * Constant representing the HMAC-MD5 keyed-hashing algorithm as defined in RFC 2104 "HMAC: Keyed-Hashing for Message Authentication" (February 1997).
+     * This algorithm uses as MD5 cryptographic hash function.
+     * @deprecated This algorithm is obsolete and and has been deprecated. Please use HmacSHA256, HmacSHA384 or HmacSHA512.
+     */
+    static readonly HMAC_MD5 = "HmacMD5";
+    /**
+     * Constant representing the HmacSHA1 algorithms as defined in RFC 2104 "HMAC: Keyed-Hashing for Message Authentication" (February 1997)
+     * with SHA-1 as the message digest algorithm.
+     * @deprecated This algorithm is obsolete and and has been deprecated. Please use HmacSHA256, HmacSHA384 or HmacSHA512.
+     */
+    static readonly HMAC_SHA_1 = "HmacSHA1";
+    /**
+     * Constant representing the HmacSHA256 algorithms as defined in RFC 2104 "HMAC: Keyed-Hashing for Message Authentication" (February 1997)
+     * with SHA-256 as the message digest algorithm.
+     */
+    static readonly HMAC_SHA_256 = "HmacSHA256";
+    /**
+     * Constant representing the HmacSHA384 algorithms as defined in RFC 2104 "HMAC: Keyed-Hashing for Message Authentication" (February 1997)
+     * with SHA-384 as the message digest algorithm.
+     */
+    static readonly HMAC_SHA_384 = "HmacSHA384";
+    /**
+     * Constant representing the HmacSHA512 algorithms as defined in RFC 2104 "HMAC: Keyed-Hashing for Message Authentication" (February 1997)
+     * with SHA-512 as the message digest algorithm.
+     */
+    static readonly HMAC_SHA_512 = "HmacSHA512";
+    /**
+     * Construct a Mac encryption instance with the specified algorithm name. The
+     * supported algorithms are:
+     * 
+     * - SHA 256
+     * - SHA 384
+     * - SHA 512
+     * @throws NullArgumentException if algorithm is null.
+     * @throws IllegalArgumentException if the specified algorithm name is not supported.
+     */
+    constructor(algorithm: string);
+    /**
+     * Computes the hash value for the passed string input using the passed secret key.
+     * Given input and the given key will be first converted with UTF-8 encoding into a byte array.
+     * The resulting hash is typically converted with base64 back into a string.
+     * @throws IllegalArgumentException if algorithm is not null and the specified algorithm name is not supported.
+     */
+    digest(input: string, key: string): Bytes;
+    /**
+     * Computes the hash value for the passed string input using the passed secret key.
+     * Given input will be first converted with UTF-8 encoding into a byte array.
+     * The resulting hash is typically converted with base64 back into a string.
+     * @throws IllegalArgumentException if algorithm is not null and the specified algorithm name is not supported.
+     */
+    digest(input: string, key: Bytes): Bytes;
+    /**
+     * Computes the hash value for the passed bytes input using the passed secret key.
+     * @throws IllegalArgumentException if algorithm is not null and the specified algorithm name is not supported.
+     */
+    digest(input: Bytes, key: Bytes): Bytes;
+}
+
+export = Mac;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/crypto/MessageDigest.d.ts

@@ -0,0 +1,108 @@
+import Bytes = require('../util/Bytes');
+
+/**
+ * This class provides the functionality of a message digest algorithm, such as
+ * MD5 or SHA. Message digests are secure one-way hash functions that take
+ * arbitrary-sized data and output a fixed-length hash value. This
+ * implementation offers only stateless digest() methods. A Bytes object or
+ * String is passed to a digest() method and the computed hash is returned.
+ * 
+ * Note: this class handles sensitive security-related data.
+ * Pay special attention to PCI DSS v3. requirements 2, 4, and 12.
+ */
+declare class MessageDigest {
+    /**
+     * Constant representing the MD2 algorithm.
+     * @deprecated This algorithm is obsolete and and has been deprecated. Please use SHA-256 or SHA-512.
+     */
+    static readonly DIGEST_MD2 = "MD2";
+    /**
+     * Constant representing the MD5 algorithm.
+     * @deprecated This algorithm is obsolete and and has been deprecated. Please use SHA-256 or SHA-512.
+     */
+    static readonly DIGEST_MD5 = "MD5";
+    /**
+     * Constant representing the SHA algorithm.
+     * @deprecated This algorithm is obsolete and and has been deprecated. Please use SHA-256 or SHA-512.
+     */
+    static readonly DIGEST_SHA = "SHA";
+    /**
+     * Constant representing the SHA 1 algorithm.
+     * @deprecated This algorithm is obsolete and and has been deprecated. Please use SHA-256 or SHA-512.
+     */
+    static readonly DIGEST_SHA_1 = "SHA-1";
+    /**
+     * Constant representing the SHA 256 algorithm
+     */
+    static readonly DIGEST_SHA_256 = "SHA-256";
+    /**
+     * Constant representing the SHA 512 algorithm
+     */
+    static readonly DIGEST_SHA_512 = "SHA-512";
+    /**
+     * Construct a MessageDigest with the specified algorithm name. The
+     * supported algorithms are:
+     * 
+     * - SHA-256
+     * - SHA-512
+     */
+    constructor(algorithm: string);
+    /**
+     * Digests the passed string and returns a computed hash value as a string.
+     * The passed String is first encoded into a sequence of bytes using the
+     * platform's default encoding. The digest then performs any prerequisite
+     * padding, before computing the hash value. The hash is then converted into
+     * a string by converting all digits to hexadecimal.
+     * @deprecated Deprecated because the conversion of the input to bytes using
+     * the default platform encoding and the hex-encoded return
+     * value are not generally appropriate.
+     */
+    digest(input: string): string;
+    /**
+     * Computes the hash value for the passed array of bytes. The algorithm
+     * argument is optional. If null, then the algorithm established at
+     * construction time is used.
+     * 
+     * The binary representation of the message is typically derived from a
+     * string and the resulting hash is typically converted with base64 back
+     * into a string. Example:
+     * 
+     * `
+     * Encoding.toBase64( digest( "MD5", new Bytes( "my password", "UTF-8" ) ) );
+     * `
+     * @deprecated Deprecated because the digest algorithm should be the one
+     * set in the constructor.
+     */
+    digest(algorithm: string | null, input: Bytes): Bytes;
+    /**
+     * Completes the hash computation by performing final operations such as
+     * padding.
+     * 
+     * The binary representation of the message is typically derived from a
+     * string and the resulting hash is typically converted with base64 back
+     * into a string. Example:
+     * 
+     * `
+     * Encoding.toBase64( digest() );
+     * `
+     */
+    digest(): Bytes;
+    /**
+     * Computes the hash value for the passed dw.util.Bytes.
+     * 
+     * The binary representation of the message is typically derived from a
+     * string and the resulting hash is typically converted with base64 back
+     * into a string. Example:
+     * 
+     * `
+     * Encoding.toBase64( digest( new Bytes( "my password", "UTF-8" ) ) );
+     * `
+     */
+    digestBytes(input: Bytes): Bytes;
+    /**
+     * Updates the digest using the passed dw.util.Bytes.
+     */
+    updateBytes(input: Bytes): void;
+}
+
+export = MessageDigest;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/crypto/SecureRandom.d.ts

@@ -0,0 +1,70 @@
+import Bytes = require('../util/Bytes');
+
+/**
+ * The SecureRandom class provides a cryptographically strong random number generator (RNG).
+ * See the Internet Engineering Task Force (IETF) RFC 1750: Randomness Recommendations for
+ * Security for more information.</a>
+ * 
+ * Typical callers of SecureRandom invoke the following methods to retrieve random bytes:
+ * 
+ * ```
+ * Bytes bytes...
+ * SecureRandom random = new SecureRandom();
+ * Bytes nextBytes = random.nextBytes(bytes);
+ * ```
+ * 
+ * or more convenient to get a Bytes with the demanded length
+ * 
+ * ```
+ * int length = 32;
+ * SecureRandom random = new SecureRandom();
+ * Bytes nextBytes = random.nextBytes(length);
+ * ```
+ * 
+ * dw.crypto.SecureRandom is intentionally an adapter for generating cryptographic hard random numbers.
+ */
+declare class SecureRandom {
+    /**
+     * Instantiates a new secure random.
+     */
+    constructor();
+    /**
+     * Returns the given number of seed bytes, computed using the seed
+     * generation algorithm that this class uses to seed itself.  This
+     * call may be used to seed other random number generators.
+     */
+    generateSeed(numBytes: number): Bytes;
+    /**
+     * Generates a user-specified number of random bytes.
+     * 
+     * If a call to `setSeed` had not occurred previously,
+     * the first call to this method forces this SecureRandom object
+     * to seed itself.  This self-seeding will not occur if
+     * `setSeed` was previously called.
+     */
+    nextBytes(numBits: number): Bytes;
+    /**
+     * Returns the next pseudorandom, uniformly distributed int value from this random number generator's sequence. The general
+     * contract of nextInt is that one int value is pseudorandomly generated and returned. All 2^32
+     * possible int values are produced with (approximately) equal probability.
+     */
+    nextInt(): number;
+    /**
+     * Returns a pseudorandom, uniformly distributed int value
+     * between 0 (inclusive) and the specified value (exclusive), drawn from
+     * this random number generator's sequence.
+     * @throws IllegalArgumentException if n is not positive
+     */
+    nextInt(upperBound: number): number;
+    /**
+     * Returns the next pseudorandom, uniformly distributed
+     * Number value between 0.0 (inclusive) and 1.0 (exclusive) from this random number generator's sequence.
+     */
+    nextNumber(): number;
+    /**
+     * Reseeds this random object. The given seed supplements, rather than replaces, the existing seed. Thus, repeated calls are guaranteed never to reduce randomness.
+     */
+    setSeed(seed: Bytes): void;
+}
+
+export = SecureRandom;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/crypto/Signature.d.ts

@@ -0,0 +1,88 @@
+import KeyRef = require('./KeyRef');
+import Bytes = require('../util/Bytes');
+import CertificateRef = require('./CertificateRef');
+
+/**
+ * 
+ * This class allows access to signature services offered through the Java
+ * Cryptography Architecture (JCA). At this time the signature/verification implementation of the
+ * methods is based on the default RSA JCE provider of the JDK - sun.security.rsa.SunRsaSign
+ * 
+ * dw.crypto.Signature is an adapter to the security provider implementation
+ * and covers several digest algorithms:
+ * 
+ * - SHA1withRSA (deprecated)
+ * - SHA256withRSA
+ * - SHA384withRSA
+ * - SHA512withRSA
+ * - SHA256withRSA/PSS
+ * - SHA384withRSA/PSS
+ * - SHA512withRSA/PSS
+ * - SHA256withECDSA
+ * - SHA384withECDSA
+ * - SHA512withECDSA
+ * 
+ * Key size generally ranges between 512 and 65536 bits (the latter of which is unnecessarily large).
+ * 
+ * Default key size for RSA is 1024. SHA384withRSA and SHA512withRSA require a key with length of at least 1024 bits.
+ * 
+ * For ECDSA, the following key sizes are supported:
+ * 
+ * - SHA256withECDSA: 256-bit key (NIST P-256)
+ * - SHA384withECDSA: 384-bit key (NIST P-384)
+ * - SHA512withECDSA: 521-bit key (NIST P-521)
+ * 
+ * When choosing a key size - beware of the tradeoff between security and processing time:
+ * 
+ * The longer the key, the harder to break it but also it takes more time for the two sides to sign and verify the signature.
+ * 
+ * An exception will be thrown for keys shorter than 2048 bits in this version of the API.
+ * 
+ * Note: this class handles sensitive security-related data.
+ * Pay special attention to PCI DSS v3. requirements 2, 4, 12, and other relevant requirements.
+ */
+declare class Signature {
+    /**
+     * Supported digest algorithms exposed as a string array
+     */
+    static readonly SUPPORTED_DIGEST_ALGORITHMS_AS_ARRAY: string[];
+    private constructor();
+    /**
+     * Checks to see if a digest algorithm is supported
+     */
+    isDigestAlgorithmSupported(digestAlgorithm: string): boolean;
+    /**
+     * Signs a string and returns a string
+     */
+    sign(contentToSign: string, privateKey: string, digestAlgorithm: string): string;
+    /**
+     * Signs a string and returns a string
+     */
+    sign(contentToSign: string, privateKey: KeyRef, digestAlgorithm: string): string;
+    /**
+     * Signs bytes and returns bytes
+     */
+    signBytes(contentToSign: Bytes, privateKey: string, digestAlgorithm: string): Bytes;
+    /**
+     * Signs bytes and returns bytes
+     */
+    signBytes(contentToSign: Bytes, privateKey: KeyRef, digestAlgorithm: string): Bytes;
+    /**
+     * Verifies a signature supplied as bytes
+     */
+    verifyBytesSignature(signature: Bytes, contentToVerify: Bytes, publicKey: string, digestAlgorithm: string): boolean;
+    /**
+     * Verifies a signature supplied as bytes
+     */
+    verifyBytesSignature(signature: Bytes, contentToVerify: Bytes, certificate: CertificateRef, digestAlgorithm: string): boolean;
+    /**
+     * Verifies a signature supplied as string
+     */
+    verifySignature(signature: string, contentToVerify: string, publicKey: string, digestAlgorithm: string): boolean;
+    /**
+     * Verifies a signature supplied as string
+     */
+    verifySignature(signature: string, contentToVerify: string, certificate: CertificateRef, digestAlgorithm: string): boolean;
+}
+
+export = Signature;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/crypto/WeakCipher.d.ts

@@ -0,0 +1,51 @@
+import CertificateRef = require('./CertificateRef');
+import Bytes = require('../util/Bytes');
+import KeyRef = require('./KeyRef');
+
+/**
+ * This API provides access to Deprecated algorithms.
+ * 
+ * See Cipher for full documentation. WeakCipher is simply a drop-in replacement that only supports
+ * deprecated algorithms and key lengths. This is helpful when you need to deal with weak algorithms for backward
+ * compatibility purposes, but Cipher should always be used for new development and for anything intended to be secure.
+ * 
+ * Note: this class handles sensitive security-related data. Pay special attention to PCI DSS v3 requirements 2,
+ * 4, and 12.
+ */
+declare class WeakCipher {
+    /**
+     * Strings containing keys, plain texts, cipher texts etc. are internally
+     * converted into byte arrays using this encoding (currently UTF8).
+     */
+    static readonly CHAR_ENCODING = "UTF8";
+    private constructor();
+    /**
+     * Decrypts the message using the given parameters. See
+     * Cipher.decrypt_1 for full documentation.
+     */
+    decrypt(base64Msg: string, key: string, transformation: string, saltOrIV: string, iterations: number): string;
+    /**
+     * Lower-level decryption API. Decrypts the passed bytes using the specified
+     * key and applying the transformations described by the specified
+     * parameters. See Cipher.decryptBytes_1 for full
+     * documentation.
+     * @see decrypt_1
+     */
+    decryptBytes(encryptedBytes: Bytes, key: string, transformation: string, saltOrIV: string, iterations: number): Bytes;
+    /**
+     * Encrypt the passed message by using the specified key and applying the
+     * transformations described by the specified parameters.
+     * 
+     * See Cipher.encrypt_1 for full documentation.
+     */
+    encrypt(message: string, key: string, transformation: string, saltOrIV: string, iterations: number): string;
+    /**
+     * Lower-level encryption API. Encrypts the passed bytes by using the specified key and applying the transformations
+     * described by the specified parameters. See Cipher.encryptBytes_1
+     * for full documentation.
+     * @see encrypt_1
+     */
+    encryptBytes(messageBytes: Bytes, key: string, transformation: string, saltOrIV: string, iterations: number): Bytes;
+}
+
+export = WeakCipher;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/crypto/WeakMac.d.ts

@@ -0,0 +1,68 @@
+import Bytes = require('../util/Bytes');
+
+/**
+ * This API provides access to Deprecated algorithms.
+ * 
+ * See Mac for full documentation. WeakMac is simply a drop-in replacement that only supports
+ * deprecated algorithms. This is helpful when you need to deal with weak algorithms for backward
+ * compatibility purposes, but Mac should always be used for new development and for anything intended to be secure.
+ * 
+ * This class provides the functionality of a "Message Authentication Code" (MAC) algorithm.
+ * A MAC provides a way to check the integrity of information transmitted over or
+ * stored in an unreliable medium, based on a secret key.
+ * Typically, message authentication codes are used between two parties
+ * that share a secret key in order to validate information transmitted between these parties.
+ * A MAC mechanism that is based on cryptographic hash functions is referred to as HMAC.
+ * HMAC can be used with any cryptographic hash function, e.g., SHA256,
+ * in combination with a secret shared key. HMAC is specified in RFC 2104.
+ * 
+ * Note: this class handles sensitive security-related data.
+ * Pay special attention to PCI DSS v3. requirements 2, 4, and 12.
+ */
+declare class WeakMac {
+    /**
+     * Constant representing the HMAC-MD5 keyed-hashing algorithm as defined in RFC 2104 "HMAC: Keyed-Hashing for Message Authentication" (February 1997).
+     * This algorithm uses as MD5 cryptographic hash function.
+     * 
+     * This algorithm is obsolete. Do not use it for any sensitive data
+     */
+    static readonly HMAC_MD5 = "HmacMD5";
+    /**
+     * Constant representing the HmacSHA1 algorithms as defined in RFC 2104 "HMAC: Keyed-Hashing for Message Authentication" (February 1997)
+     * with SHA-1 as the message digest algorithm.
+     * 
+     * This algorithm is obsolete. Do not use it for any sensitive data
+     */
+    static readonly HMAC_SHA_1 = "HmacSHA1";
+    /**
+     * Construct a Mac encryption instance with the specified algorithm name. The
+     * supported algorithms are:
+     * 
+     * - HmacMD5
+     * - HmacSHA1
+     * @throws NullArgumentException if algorithm is null.
+     * @throws IllegalArgumentException if the specified algorithm name is not supported.
+     */
+    constructor(algorithm: string);
+    /**
+     * Computes the hash value for the passed string input using the passed secret key.
+     * Given input and the given key will be first converted with UTF-8 encoding into a byte array.
+     * The resulting hash is typically converted with base64 back into a string.
+     * @throws IllegalArgumentException if algorithm is not null and the specified algorithm name is not supported.
+     */
+    digest(input: string, key: string): Bytes;
+    /**
+     * Computes the hash value for the passed string input using the passed secret key.
+     * Given input will be first converted with UTF-8 encoding into a byte array.
+     * The resulting hash is typically converted with base64 back into a string.
+     * @throws IllegalArgumentException if algorithm is not null and the specified algorithm name is not supported.
+     */
+    digest(input: string, key: Bytes): Bytes;
+    /**
+     * Computes the hash value for the passed bytes input using the passed secret key.
+     * @throws IllegalArgumentException if algorithm is not null and the specified algorithm name is not supported.
+     */
+    digest(input: Bytes, key: Bytes): Bytes;
+}
+
+export = WeakMac;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/crypto/WeakMessageDigest.d.ts

@@ -0,0 +1,100 @@
+import Bytes = require('../util/Bytes');
+
+/**
+ * This API provides access to Deprecated algorithms.
+ * 
+ * See MessageDigest for full documentation. WeakMessageDigest is simply a drop-in replacement that only supports
+ * deprecated algorithms. This is helpful when you need to deal with weak algorithms for backward
+ * compatibility purposes, but MessageDigest should always be used for new development and for anything intended to be secure.
+ * 
+ * Note: this class handles sensitive security-related data.
+ * Pay special attention to PCI DSS v3. requirements 2, 4, and 12.
+ */
+declare class WeakMessageDigest {
+    /**
+     * Constant representing the MD2 algorithm.
+     * 
+     * This algorithm is obsolete. Do not use it for any sensitive data
+     */
+    static readonly DIGEST_MD2 = "MD2";
+    /**
+     * Constant representing the MD5 algorithm.
+     * 
+     * This algorithm is obsolete. Do not use it for any sensitive data
+     */
+    static readonly DIGEST_MD5 = "MD5";
+    /**
+     * Constant representing the SHA algorithm.
+     * 
+     * This algorithm is obsolete. Do not use it for any sensitive data
+     */
+    static readonly DIGEST_SHA = "SHA";
+    /**
+     * Constant representing the SHA 1 algorithm.
+     * 
+     * This algorithm is obsolete. Do not use it for any sensitive data
+     */
+    static readonly DIGEST_SHA_1 = "SHA-1";
+    /**
+     * Construct a MessageDigest with the specified algorithm name.
+     */
+    constructor(algorithm: string);
+    /**
+     * Digests the passed string and returns a computed hash value as a string.
+     * The passed String is first encoded into a sequence of bytes using the
+     * platform's default encoding. The digest then performs any prerequisite
+     * padding, before computing the hash value. The hash is then converted into
+     * a string by converting all digits to hexadecimal.
+     * @deprecated Deprecated because the conversion of the input to bytes using
+     * the default platform encoding and the hex-encoded return
+     * value are not generally appropriate.
+     */
+    digest(input: string): string;
+    /**
+     * Computes the hash value for the passed array of bytes. The algorithm
+     * argument is optional. If null, then the algorithm established at
+     * construction time is used.
+     * 
+     * The binary representation of the message is typically derived from a
+     * string and the resulting hash is typically converted with base64 back
+     * into a string. Example:
+     * 
+     * `
+     * Encoding.toBase64( digest( "MD5", new Bytes( "my password", "UTF-8" ) ) );
+     * `
+     * @deprecated Deprecated because the digest algorithm should be the one
+     * set in the constructor.
+     */
+    digest(algorithm: string | null, input: Bytes): Bytes;
+    /**
+     * Completes the hash computation by performing final operations such as
+     * padding.
+     * 
+     * The binary representation of the message is typically derived from a
+     * string and the resulting hash is typically converted with base64 back
+     * into a string. Example:
+     * 
+     * `
+     * Encoding.toBase64( digest() );
+     * `
+     */
+    digest(): Bytes;
+    /**
+     * Computes the hash value for the passed dw.util.Bytes.
+     * 
+     * The binary representation of the message is typically derived from a
+     * string and the resulting hash is typically converted with base64 back
+     * into a string. Example:
+     * 
+     * `
+     * Encoding.toBase64( digest( new Bytes( "my password", "UTF-8" ) ) );
+     * `
+     */
+    digestBytes(input: Bytes): Bytes;
+    /**
+     * Updates the digest using the passed dw.util.Bytes.
+     */
+    updateBytes(input: Bytes): void;
+}
+
+export = WeakMessageDigest;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/crypto/WeakSignature.d.ts

@@ -0,0 +1,63 @@
+import KeyRef = require('./KeyRef');
+import Bytes = require('../util/Bytes');
+import CertificateRef = require('./CertificateRef');
+
+/**
+ * This API provides access to Deprecated algorithms.
+ * 
+ * See Signature for full documentation. WeakSignature is simply a drop-in replacement that only supports
+ * deprecated algorithms. This is helpful when you need to deal with weak algorithms for backward compatibility
+ * purposes, but Signature should always be used for new development and for anything intended to be secure.
+ * 
+ * This class allows access to signature services offered through the Java Cryptography Architecture (JCA). At this time
+ * the signature/verification implementation of the methods is based on the default RSA JCE provider of the JDK -
+ * sun.security.rsa.SunRsaSign
+ * 
+ * dw.crypto.WeakSignature is an adapter to the security provider implementation and only covers one digest algorithm:
+ * 
+ * - SHA1withRSA
+ * 
+ * Note: this class handles sensitive security-related data. Pay special attention to PCI DSS v3. requirements 2,
+ * 4, 12, and other relevant requirements.
+ */
+declare class WeakSignature {
+    private constructor();
+    /**
+     * Checks to see if a digest algorithm is supported
+     */
+    isDigestAlgorithmSupported(digestAlgorithm: string): boolean;
+    /**
+     * Signs a string and returns a string
+     */
+    sign(contentToSign: string, privateKey: string, digestAlgorithm: string): string;
+    /**
+     * Signs a string and returns a string
+     */
+    sign(contentToSign: string, privateKey: KeyRef, digestAlgorithm: string): string;
+    /**
+     * Signs bytes and returns bytes
+     */
+    signBytes(contentToSign: Bytes, privateKey: string, digestAlgorithm: string): Bytes;
+    /**
+     * Signs bytes and returns bytes
+     */
+    signBytes(contentToSign: Bytes, privateKey: KeyRef, digestAlgorithm: string): Bytes;
+    /**
+     * Verifies a signature supplied as bytes
+     */
+    verifyBytesSignature(signature: Bytes, contentToVerify: Bytes, publicKey: string, digestAlgorithm: string): boolean;
+    /**
+     * Verifies a signature supplied as bytes
+     */
+    verifyBytesSignature(signature: Bytes, contentToVerify: Bytes, certificate: CertificateRef, digestAlgorithm: string): boolean;
+    /**
+     * Verifies a signature supplied as string
+     */
+    verifySignature(signature: string, contentToVerify: string, publicKey: string, digestAlgorithm: string): boolean;
+    /**
+     * Verifies a signature supplied as string
+     */
+    verifySignature(signature: string, contentToVerify: string, certificate: CertificateRef, digestAlgorithm: string): boolean;
+}
+
+export = WeakSignature;