@salesforce/b2c-cli 1.10.0 → 1.12.0

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

@@ -0,0 +1,20 @@
+/**
+ * This class is used as a reference to a certificate or public key.
+ * 
+ * Note: this class handles sensitive security-related data.
+ * Pay special attention to PCI DSS v3. requirements 2, 4, and 12.
+ */
+declare class CertificateRef {
+    /**
+     * Creates a `CertificateRef` from the passed alias as a reference to a certificate in Business Manager.
+     * No check is made whether the alias is actually valid until the time that this `CertificateRef` is
+     * used to resolve a certificate or public key.
+     */
+    constructor(alias: string);
+    /**
+     * Returns the string representation of this CertificateRef.
+     */
+    toString(): string;
+}
+
+export = CertificateRef;

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

@@ -0,0 +1,54 @@
+import X509Certificate = require('./X509Certificate');
+import CertificateRef = require('./CertificateRef');
+import KeyRef = require('./KeyRef');
+
+/**
+ * Utilities for managing certificates and keys.
+ */
+declare class CertificateUtils {
+    private constructor();
+    /**
+     * Gets the certificate from the given certificate reference.
+     * @throws Exception if the reference is invalid or does not refer to an X.509 certificate
+     */
+    static getCertificate(certificateRef: CertificateRef): X509Certificate;
+    /**
+     * Gets the public certificate from the given private key reference.
+     * @throws Exception if the reference is invalid or there is no X.509 certificate
+     */
+    static getCertificate(keyRef: KeyRef): X509Certificate;
+    /**
+     * Encode the certificate to the base64-encoded DER format.
+     */
+    static getEncodedCertificate(certificateRef: CertificateRef): string;
+    /**
+     * Gets the public key from the given certificate reference.
+     * 
+     * It is exported in the standard X.509 SubjectPublicKeyInfo format and base64-encoded.
+     */
+    static getEncodedPublicKey(certificateRef: CertificateRef): string;
+    /**
+     * Parse the certificate from the base64-encoded DER format.
+     */
+    static parseEncodedCertificate(certificate: string): CertificateRef;
+    /**
+     * Parse the public key from the given key in X.509 SubjectPublicKeyInfo format.
+     * 
+     * The resulting reference contains only the public key. It can be used for cryptographic operations, but not
+     * anything that requires the full certificate.
+     */
+    static parseEncodedPublicKey(algorithm: string, encodedKey: string): CertificateRef;
+    /**
+     * Parse the public key from the given base64-encoded JWK string.
+     * 
+     * This returns the public key portion of the JWK, not the `x5c` certificate chain.
+     * 
+     * Only RSA and EC keys are supported.
+     * 
+     * The resulting reference contains only the public key. It can be used for cryptographic operations, but not
+     * anything that requires the full certificate.
+     */
+    static parsePublicKeyFromJWK(jwk: string): CertificateRef;
+}
+
+export = CertificateUtils;

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

@@ -0,0 +1,178 @@
+import CertificateRef = require('./CertificateRef');
+import Bytes = require('../util/Bytes');
+import KeyRef = require('./KeyRef');
+
+/**
+ * This class allows access to encryption services offered through the Java
+ * Cryptography Architecture (JCA). At this time the implementation of the
+ * encryption/decryption methods is based on the default JCE provider of the JDK.
+ * See the Java documentation for a reference guide to the underlying security
+ * provider and information about the Secure Sockets Extension.
+ * 
+ * You can find a good overview of the essential purposes of cryptography and
+ * some common implementations in the Wikipedia article on cryptography.
+ * Also see the website of the National Institute of Standards and Technology.
+ * The format of various files used to hold keys, certificate signing requests,
+ * and the like, as well as some related algorithms, are defined in the PKCS series of
+ * documents published by RSALabs (the research arm of RSA Security).
+ * 
+ * Many internet standards documenting security protocols and concepts are described
+ * in documents originally described as "Request For Comment" and thus widely known
+ * as RFCs. Many of them are available on the Internet FAQ Archives website.
+ * 
+ * dw.crypto.Cipher is intentionally an Adapter to the full cryptography power supplied
+ * in the security provider implementation.
+ * 
+ * Note: this class handles sensitive security-related data.
+ * Pay special attention to PCI DSS v3 requirements 2, 4, and 12.
+ */
+declare class Cipher {
+    /**
+     * 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 passed Base-64 encoded message using the passed key and
+     * applying the transformations described by the passed parameters.
+     * 
+     * Decryption is the process of getting back the original data from the
+     * cipher-text using a decryption key.
+     */
+    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.
+     * 
+     * Typical usage:
+     * @example
+     * var base64Msg : String = "some_encoded_encrypted_message";
+     * var charset : String = "UTF8";  // or "windows-1252", etc.
+     * 
+     * var encryptedBytes : Bytes = Encoding.fromBase64(base64Msg);
+     * var messageBytes : Bytes = Cipher.decryptBytes(encryptedBytes, key, transformation, salt, iterations);
+     * var message : String = messageBytes.toString(charset);
+     * @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.
+     * 
+     * Encryption is the process of converting normal data or plain text to
+     * something incomprehensible or cipher-text by applying transformations,
+     * which are the operation (or set of operations) to be performed on given input
+     * to produce some output. A transformation always includes the name of a
+     * cryptographic algorithm (for example, RSA) and may be followed by a mode and padding scheme.
+     * The supported algorithms are listed in the parameter description below.
+     * 
+     * The cryptographic algorithms can be partitioned into symmetric
+     * and asymmetric (or public key/private key).
+     * 
+     * Symmetric or "secret key" algorithms use the same key to encrypt
+     * and to decrypt the data. Symmetric algorithms are what most people think
+     * of as codes: using a well-known algorithm and a secret key to encode information,
+     * which can be decoded using the same algorithm and the same key. The algorithm
+     * is not secret, the secrecy is inherent to guarding the key. A significant
+     * problem with symmetric ciphers is that it is difficult to transfer the keys
+     * themselves securely. Symmetric algorithms include password-based algorithms.
+     * 
+     * AES with key length of 256 bits is the preferred choice for symmetric encryption going forward.
+     * Please consider switching to it if you are using any other scheme or if using AES with a
+     * shorter key length. The rest of the symmetric algorithms will be deprecated in the future.
+     * 
+     * Asymmetric or "public key" cryptography uses a public/private key pair, and then publishes the public key.
+     * Only the holder of the private key will be able to decrypt.
+     * The public key and private key together are also called a "key pair".
+     * Data encrypted with one key can only be decrypted using the other key
+     * from the pair, and it is not possible to deduce one key from the other.
+     * This helps to solve the key distribution problem since it is possible to
+     * publicise one of the keys widely (the "public key") and keep the other
+     * a closely guarded secret (the "private key"). Many partners can then
+     * send data encrypted with the public key, but only the holder of the
+     * corresponding private key can decrypt it.
+     * 
+     * Key pairs for asymmetric ciphers can be generated with an arbitrary tool.
+     * One of the most popular options is the open source tool OpenSSL.
+     * OpenSSL has a command-line syntax and is available on major platforms.
+     * 
+     * The following steps are involved in creating an RSA key pair:
+     * 
+     * - Generate an RSA private key with keylength of 2048 bits. Store this key in a safe place.
+     * 
+     * ```
+     * openssl genrsa -out rsaprivatekey.pem 2048
+     * ```
+     * 
+     * - Generate a public key from the private key. You use the public key to encrypt messages with Cipher.encrypt. OpenSSL saves the key PEM-encoded; this means the key is saved with a base64 encoding. After you removed the header and footer lines you can pass the content directly to the API method.
+     * 
+     * ```
+     * openssl rsa -in rsaprivatekey.pem -out publickey.pem -pubout
+     * ```
+     * 
+     * - Generate a private key in PKCS#8 format. You use that key to decrypt messages with Cipher.decrypt. OpenSSL saves the key PEM-encoded; this means the key is saved with a base64 encoding. After you removed the header and footer lines you can pass the content directly to the API method.
+     * 
+     * ```
+     * openssl pkcs8 -topk8 -in rsaprivatekey.pem -out privatekey.pem -nocrypt
+     * ```
+     * 
+     * Modes
+     * 
+     * The following modes of operation are block cipher operations that
+     * are used with some algorithms.
+     * 
+     * - "NONE" no mode
+     * - "CBC" Cipher Block Chaining (defined in FIPS PUB 81)
+     * - "CTR" Counter mode or Segmented Integer Counter mode (defined in FIPS PUB 81)
+     * - "CTS" CipherText Streaming mode
+     * - "CFB" Cipher Feedback Mode,  can be referred to with key
+     * length referenced as "CFB8","CFB16","CFB24".."CFB64" (defined in FIPS PUB 81)
+     * - "ECB" Electronic Cook book  as defined in: The National
+     * Institute of Standards and Technology (NIST) Federal Information
+     * Processing Standard (FIPS) PUB 81, "DES Modes of Operation,"
+     * U.S. Department of Commerce, Dec 1980.
+     * - "OFB" Output Feedback Mode, can be referred to with key
+     * length referenced as "OFB8","OFB16","OFB24".."OFB64" (defined in FIPS PUB 81)
+     * - "PCBC" Propagating Cipher Block Chaining (defined in Kerberos V4)
+     * 
+     * Paddings
+     * 
+     * - "NoPadding": No padding.
+     * - OAEPWith<digest>And<mgf>Padding:
+     * 
+     * Optimal Asymmetric Encryption
+     * Padding scheme defined in PKCS#1, where <digest> should be replaced
+     * by the message digest and <mgf> by the mask generation function.
+     * 
+     * Examples: OAEPWITHSHA-256ANDMGF1PADDING, OAEPWITHSHA-384ANDMGF1PADDING, OAEPWITHSHA-512ANDMGF1PADDING
+     * - ISO10126PADDING: the ISO10126-2:1991 DEA padding scheme
+     * - PKCS1Padding: Public Key Cryptography Standard #1, a standard
+     * for padding from RSA Laboratories that can encrypt messages up
+     * to 11 bytes smaller than the modulus size in bytes.
+     * - PKCS5Padding: Public Key Cryptography Standard #1, a standard
+     * for padding from RSA Laboratories, "PKCS#5: Password-Based Encryption Standard," version 1.5, November 1993.
+     * - SSL3Padding: The padding scheme defined in the SSL Protocol Version 3.0, November 18, 1996, section 5.2.3.2 (CBC block cipher)
+     */
+    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.
+     * 
+     * Typical usage:
+     * @example
+     * var message : String = "some_message";
+     * var charset : String = "UTF8"; // or "windows-1252", etc.
+     * 
+     * // encrypt the message
+     * var messageBytes : Bytes = new Bytes(message, charset);
+     * var encryptedBytes : Bytes = Cipher.encryptBytes(messageBytes, key, transformation, salt, iterations);
+     * var encrypted : String = Encoding.toBase64(encryptedBytes);
+     * @see encrypt_1
+     */
+    encryptBytes(messageBytes: Bytes, key: string, transformation: string, saltOrIV: string, iterations: number): Bytes;
+}
+
+export = Cipher;

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

@@ -0,0 +1,78 @@
+import Bytes = require('../util/Bytes');
+
+/**
+ * Utility class which handles several common character encodings.
+ */
+declare class Encoding {
+    private constructor();
+    /**
+     * Decode the given string which represents a sequence of characters encoded in base-64 to a byte array. This
+     * operation supports both the base-64 and base-64 for URL formats. Characters not in the base-64 alphabet are
+     * ignored. An exception is thrown if a null value is passed.
+     * 
+     * Note: This decoding operation is limited to the maximum number of bytes that a Bytes object can hold. See
+     * dw.util.Bytes.
+     */
+    static fromBase64(string: string): Bytes;
+    /**
+     * Converts a String representing hexadecimal values into an array of bytes
+     * of those same values. The returned byte array will be half the length of
+     * the passed, as it takes two characters to represent any given byte. An
+     * exception is thrown if the passed string has an odd number of character
+     * or if any characters in the string are not valid hexadecimal characters.
+     * An exception is thrown if a null value is passed.
+     * 
+     * Note: This decoding operation is limited to the maximum number of bytes
+     * that a Bytes object can hold. See dw.util.Bytes.
+     */
+    static fromHex(string: string): Bytes;
+    /**
+     * Decodes a URL safe string into its original form. Escaped characters are
+     * converted back to their original representation. An exception is thrown
+     * if URL decoding is unsuccessful or if null is passed.
+     */
+    static fromURI(string: string): string;
+    /**
+     * Decodes a URL safe string into its original form using the specified
+     * encoding. Escaped characters are converted back to their original
+     * representation. An exception is thrown if URL decoding is unsuccessful or
+     * if the specified encoding is unsupported or if null is passed for either
+     * argument.
+     */
+    static fromURI(string: string, encoding: string): string;
+    /**
+     * Convert the given byte array to a string encoded in base-64.  This method
+     * does not chunk the data by adding line breaks.  An exception is thrown
+     * if a null value is passed.
+     */
+    static toBase64(bytes: Bytes): string;
+    /**
+     * Convert the given byte array to a string encoded in base-64 for URLs.  This method does not chunk the data by
+     * adding line breaks and it does not add any padding.  An exception is thrown if a null value is passed.
+     */
+    static toBase64URL(bytes: Bytes): string;
+    /**
+     * Converts an array of bytes into a string representing the hexadecimal
+     * values of each byte in order. The returned string will be double the
+     * length of the passed array, as it takes two characters to represent any
+     * given byte. An exception is thrown if a null value is passed.
+     */
+    static toHex(bytes: Bytes): string;
+    /**
+     * Encodes a string into its URL safe form according to the
+     * "application/x-www-form-urlencoded" encoding scheme using the default
+     * encoding. Unsafe characters are escaped. An exception is thrown if a null
+     * value is passed.
+     */
+    static toURI(string: string): string;
+    /**
+     * Encodes a string into its URL safe form according to the
+     * "application/x-www-form-urlencoded" encoding scheme using the specified
+     * encoding. Unsafe characters are escaped. An exception is thrown if the
+     * specified encoding is unsupported. An exception is thrown if either
+     * argument is null.
+     */
+    static toURI(string: string, encoding: string): string;
+}
+
+export = Encoding;

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

@@ -0,0 +1,114 @@
+import JWEHeader = require('./JWEHeader');
+import Bytes = require('../util/Bytes');
+import utilMap = require('../util/Map');
+import KeyRef = require('./KeyRef');
+import CertificateRef = require('./CertificateRef');
+
+/**
+ * This class represents a JSON Web Encryption (JWE) object.
+ * 
+ * Note: this class handles sensitive security-related data.
+ * Pay special attention to PCI DSS v3 requirements 2, 4, and 12.
+ */
+declare class JWE {
+    /**
+     * Get the algorithm (`alg`) from the header.
+     */
+    readonly algorithm: string | null;
+    /**
+     * Get the encryption method (`enc`) from the header.
+     */
+    readonly encryptionMethod: string | null;
+    /**
+     * Get a copy of the JWE headers as a Map.
+     */
+    readonly headerMap: utilMap<any, any>;
+    /**
+     * Get the key id (`kid`) from the header.
+     */
+    readonly keyID: string | null;
+    /**
+     * Get the decrypted payload.
+     */
+    readonly payload: string | null;
+    /**
+     * Construct a new JWE for encryption.
+     */
+    constructor(header: JWEHeader, payload: string);
+    /**
+     * Construct a new JWE for encryption.
+     */
+    constructor(header: JWEHeader, payload: Bytes);
+    /**
+     * Parse a JSON Web Encryption (JWE) object from its compact serialization format.
+     */
+    static parse(jwe: string): JWE;
+    /**
+     * Decrypt the payload of this JWE object.
+     * 
+     * Elliptic Curve (EC) and RSA keys are both supported.
+     * 
+     * Supported EC key management algorithms:
+     * 
+     * - ECDH-ES
+     * - ECDH-ES+A128KW
+     * - ECDH-ES+A192KW
+     * - ECDH-ES+A256KW
+     * 
+     * Supported EC curves:
+     * 
+     * - P-256
+     * - P-384
+     * - P-521
+     * 
+     * Supported RSA key management algorithms:
+     * 
+     * - RSA-OAEP-256
+     * - RSA-OAEP-384
+     * - RSA-OAEP-512
+     * 
+     * Supported content encryption algorithms:
+     * 
+     * - A128CBC-HS256
+     * - A128CBC-HS384
+     * - A128CBC-HS512
+     * - A128GCM
+     * - A192GCM
+     * - A256GCM
+     */
+    decrypt(privateKey: KeyRef): void;
+    /**
+     * Encrypt the payload of this JWE object.
+     * 
+     * Elliptic Curve (EC) and RSA keys are both supported.
+     * 
+     * See decrypt for the list of supported algorithms and encryption methods.
+     */
+    encrypt(publicKey: CertificateRef): void;
+    /**
+     * Get the algorithm (`alg`) from the header.
+     */
+    getAlgorithm(): string | null;
+    /**
+     * Get the encryption method (`enc`) from the header.
+     */
+    getEncryptionMethod(): string | null;
+    /**
+     * Get a copy of the JWE headers as a Map.
+     */
+    getHeaderMap(): utilMap<any, any>;
+    /**
+     * Get the key id (`kid`) from the header.
+     */
+    getKeyID(): string | null;
+    /**
+     * Get the decrypted payload.
+     */
+    getPayload(): string | null;
+    /**
+     * Get this JWE in compact serialization form.
+     */
+    serialize(): string;
+}
+
+export = JWE;

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

@@ -0,0 +1,55 @@
+import utilMap = require('../util/Map');
+
+/**
+ * This class represents an immutable header of a JWE (JSON Web Encryption) object.
+ */
+declare class JWEHeader {
+    /**
+     * Get the value of the algorithm parameter (`alg`).
+     */
+    readonly algorithm: string;
+    /**
+     * Get the value of the encryption algorithm parameter (`enc`).
+     */
+    readonly encryptionAlgorithm: string;
+    private constructor();
+    /**
+     * Convert the given Map or JavaScript object into a JWE header.
+     * 
+     * All keys correspond to JWE parameters. The algorithm (`alg`) and encryption method
+     * (`enc`) parameters are required. See JWE.decrypt for supported values.
+     */
+    static parse(map: Object): JWEHeader;
+    /**
+     * Parse the given string as a Base64URL-encoded JWE header.
+     * 
+     * The algorithm (`alg`) and encryption method (`enc`) parameters are required. See
+     * JWE.decrypt for supported values.
+     */
+    static parseEncoded(base64encoded: string): JWEHeader;
+    /**
+     * Parse the given string as a JWE header.
+     * 
+     * The algorithm (`alg`) and encryption method (`enc`) parameters are required. See
+     * JWE.decrypt for supported values.
+     */
+    static parseJSON(json: string): JWEHeader;
+    /**
+     * Get the value of the algorithm parameter (`alg`).
+     */
+    getAlgorithm(): string;
+    /**
+     * Get the value of the encryption algorithm parameter (`enc`).
+     */
+    getEncryptionAlgorithm(): string;
+    /**
+     * Get a copy of these headers as a Map.
+     */
+    toMap(): utilMap<any, any>;
+    /**
+     * Get the content of the headers as a JSON String.
+     */
+    toString(): string;
+}
+
+export = JWEHeader;

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

@@ -0,0 +1,105 @@
+import JWSHeader = require('./JWSHeader');
+import Bytes = require('../util/Bytes');
+import utilMap = require('../util/Map');
+import CertificateRef = require('./CertificateRef');
+import KeyRef = require('./KeyRef');
+
+/**
+ * This class represents a JSON Web Signature (JWS) object.
+ * 
+ * Note: this class handles sensitive security-related data.
+ * Pay special attention to PCI DSS v3 requirements 2, 4, and 12.
+ */
+declare class JWS {
+    /**
+     * Get the algorithm (`alg`) from the header.
+     */
+    readonly algorithm: string | null;
+    /**
+     * Get a copy of the JWS header.
+     */
+    readonly header: JWSHeader;
+    /**
+     * Get a copy of the JWS header as a Map.
+     */
+    readonly headerMap: utilMap<any, any>;
+    /**
+     * Get the payload from this object.
+     * 
+     * This is available even if the signature has not been verified.
+     */
+    readonly payload: string;
+    /**
+     * Construct a new JWS for signing.
+     */
+    constructor(header: JWSHeader, payload: string);
+    /**
+     * Construct a new JWS for signing.
+     */
+    constructor(header: JWSHeader, payload: Bytes);
+    /**
+     * Parse a JSON Web Signature (JWS) object from its compact serialization format.
+     */
+    static parse(jws: string): JWS;
+    /**
+     * Parse a JSON Web Signature (JWS) object from its compact serialization format.
+     */
+    static parse(jws: string, payload: string): JWS;
+    /**
+     * Parse a JSON Web Signature (JWS) object from its compact serialization format.
+     */
+    static parse(jws: string, payload: Bytes): JWS;
+    /**
+     * Get the algorithm (`alg`) from the header.
+     */
+    getAlgorithm(): string | null;
+    /**
+     * Get a copy of the JWS header.
+     */
+    getHeader(): JWSHeader;
+    /**
+     * Get a copy of the JWS header as a Map.
+     */
+    getHeaderMap(): utilMap<any, any>;
+    /**
+     * Get the payload from this object.
+     * 
+     * This is available even if the signature has not been verified.
+     */
+    getPayload(): string;
+    /**
+     * Get this JWS in compact serialization form.
+     */
+    serialize(detachPayload: boolean): string;
+    /**
+     * Sign the payload using the given private key.
+     * 
+     * The key type and size must match the algorithm given in the JWS header.
+     * @throws Exception if there is an error while signing the payload.
+     */
+    sign(keyRef: KeyRef): void;
+    /**
+     * Verifies the signature of the payload.
+     * 
+     * If the `x5c` header parameter is present, then that certificate chain will be used to verify the
+     * signature and the given `certificateRef` must be its root certificate. If this parameter is not
+     * present then the given `certificateRef` will be used to directly verify the signature.
+     * 
+     * The following algorithms are supported:
+     * 
+     * - ES256
+     * - ES256K
+     * - ES384
+     * - ES512
+     * - RS256
+     * - RS384
+     * - RS512
+     * - PS256
+     * - PS384
+     * - PS512
+     * @throws Exception if there is an error while processing the certificate (for example if the  x5c is not signed by the given certificate) or the algorithm is unsupported.
+     */
+    verify(certificateRef: CertificateRef): boolean;
+}
+
+export = JWS;

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

@@ -0,0 +1,47 @@
+import utilMap = require('../util/Map');
+
+/**
+ * This class represents an immutable header of a JWS (JSON Web Signature) object.
+ */
+declare class JWSHeader {
+    /**
+     * Get the value of the algorithm parameter (`alg`).
+     */
+    readonly algorithm: string;
+    private constructor();
+    /**
+     * Convert the given Map or JavaScript object into a JWS header.
+     * 
+     * All keys correspond to JWS parameters. The algorithm parameter (`alg`) is required. See
+     * JWS.verify for supported values.
+     */
+    static parse(map: Object): JWSHeader;
+    /**
+     * Parse the given string as a Base64URL-encoded JWS header.
+     * 
+     * The algorithm parameter (`alg`) is required. See JWS.verify for supported
+     * values.
+     */
+    static parseEncoded(base64encoded: string): JWSHeader;
+    /**
+     * Parse the given string as a JWS header.
+     * 
+     * The algorithm parameter (`alg`) is required. See JWS.verify for supported
+     * values.
+     */
+    static parseJSON(json: string): JWSHeader;
+    /**
+     * Get the value of the algorithm parameter (`alg`).
+     */
+    getAlgorithm(): string;
+    /**
+     * Get a copy of these headers as a Map.
+     */
+    toMap(): utilMap<any, any>;
+    /**
+     * Get the content of the headers as a JSON String.
+     */
+    toString(): string;
+}
+
+export = JWSHeader;

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

@@ -0,0 +1,28 @@
+/**
+ * This class is used as a reference to a private key in the keystore
+ * which can be managed in the Business Manager.
+ * 
+ * Note: this class handles sensitive security-related data.
+ * Pay special attention to PCI DSS v3. requirements 2, 4, and 12.
+ */
+declare class KeyRef {
+    /**
+     * Creates a `KeyRef` from the passed alias. No check
+     * is made whether the alias is actually referring to a key in the keystore,
+     * this check is made when the `KeyRef` is used.
+     */
+    constructor(alias: string);
+    /**
+     * Creates a `KeyRef` from the passed alias. No check
+     * is made whether the alias is actually referring to a key in the keystore,
+     * this check is made when the `KeyRef` is used.
+     * @deprecated use KeyRef instead
+     */
+    constructor(alias: string, password: string);
+    /**
+     * Returns the string representation of this KeyRef.
+     */
+    toString(): string;
+}
+
+export = KeyRef;