@types/k6 0.43.3 → 0.44.1

k6/experimental/redis.d.ts

@@ -36,7 +36,7 @@ export class Client {
      * @param expiration - time to live in seconds. `0` means no expiration.
      * @returns a promise that resolves to "OK" if the operation succeeded.
      */
-    set(key: string, value: any, expiration: number): Promise<string>;
+    set(key: string, value: string | number | boolean, expiration: number): Promise<string>;
 
     /**
      * Gets the value of a key.
@@ -58,7 +58,7 @@ export class Client {
      * @param value - value to set
      * @returns a promise that resolves to the old value of the key.
      */
-    getSet(key: string, value: any): Promise<string>;
+    getSet(key: string, value: string | number | boolean): Promise<string>;
 
     /**
      * Removes the specified keys.
@@ -212,7 +212,7 @@ export class Client {
      * @param values - values to prepend to the list
      * @returns a promise that resolves to the number of elements in the list after the prepend operation.
      */
-    lpsuh(key: string, values: any[]): Promise<number>;
+    lpsuh(key: string, ...values: Array<string | number | boolean>): Promise<number>;
 
     /**
      * Appends values to a list, creating the list if it does not already exist.
@@ -225,7 +225,7 @@ export class Client {
      * @param values - values to append to the list
      * @returns a promise that resolves to the number of elements in the list after the append operation.
      */
-    rpush(key: string, values: any[]): Promise<number>;
+    rpush(key: string, ...values: Array<string | number | boolean>): Promise<number>;
 
     /**
      * Removes and returns the value at the head of the list stored at key.
@@ -329,7 +329,7 @@ export class Client {
      * @param value - value to set the field to
      * @returns a promise that resolves to the the number of fields that were changed.
      */
-    hset(key: string, field: string, value: string): Promise<number>;
+    hset(key: string, field: string, value: string | number | boolean): Promise<number>;
 
     /**
      * Sets the value of a hash field to the specified value, if and only if the field does not yet exist.
@@ -437,7 +437,7 @@ export class Client {
      * @param members - the members to add to the set
      * @returns a promise that resolves to the number of members that were added to the set; excluding those that were already present.
      */
-    sadd(key: string, members: any[]): Promise<number>;
+    sadd(key: string, ...members: Array<string | number | boolean>): Promise<number>;
 
     /**
      * Removes the specified members from the set stored at key.
@@ -451,7 +451,7 @@ export class Client {
      * @param members - the members to remove from the set
      * @returns a promise that resolves to the number of members that were removed from the set.
      */
-    srem(key: string, members: any[]): Promise<number>;
+    srem(key: string, ...members: Array<string | number | boolean>): Promise<number>;
 
     /**
      * Returns whether or not the specified member is a member of the set stored at key.
@@ -462,7 +462,7 @@ export class Client {
      * @param member - the member to check the belonging of
      * @returns a promise that resolves to true if the member is a member of the set, false otherwise.
      */
-    sismember(key: string, member: any): Promise<boolean>;
+    sismember(key: string, member: string | number | boolean): Promise<boolean>;
 
     /**
      * Returns the members of the set stored at key.

k6/experimental/webcrypto.d.ts

@@ -0,0 +1,401 @@
+/**
+ * This module provides a subset of the Web Crypto API. It is an interface
+ * allowing a k6 script to use cryptographic primitives.
+ *
+ * https://k6.io/docs/javascript-api/k6-experimental/webcrypto/
+ */
+
+export const crypto: Crypto;
+
+export interface Crypto extends SubtleCrypto {
+    /**
+     * Returns a SubtleCrypto object providing access to common cryptographic
+     * primitives, like hashing, signing, encryption, or decryption.
+     */
+    readonly subtle: SubtleCrypto;
+
+    /**
+     * Fills the passed TypedArray with cryptographically sound random values.
+     *
+     *
+     * @param typedArray - The TypedArray to fill with random values.
+     * @throws {QuotaExceededError} - thrown if the `byteLength` of `typedArray` exceeds 65536.
+     * @returns The typedArray argument.
+     */
+    getRandomValues(typedArray: TypedArray): TypedArray;
+
+    /**
+     * Returns a 36 character long string containing a cryptographically random UUID v4.
+     *
+     * @returns A 36 character long string containing a cryptographically random UUID v4.
+     */
+    randomUUID(): string;
+}
+
+export interface SubtleCrypto {
+    /**
+     * The `decrypt()` method decrypts some encrypted data.
+     *
+     * @param algorithm defines the algorithm to use and any extra-parameters.
+     * @param key the key to use for decryption.
+     * @param data the data to decrypt (also known as "ciphertext").
+     * @throws {InvalidAccessError} - if the provided key cannot be used for the decrypt operation.
+     * @throws {OperationError} - if the operation failed for an operation-specific reason.
+     * @returns A promise that resolves with the decrypted data (also known as "plaintext").
+     */
+    decrypt(
+        algorithm: AesCtrParams | AesCbcParams | AesGcmParams,
+        key: CryptoKey,
+        data: ArrayBuffer | ArrayBufferView | DataView
+    ): Promise<ArrayBuffer>;
+
+    /**
+     * The `digest()` method computes a cryptographic digest of the given data using the
+     * given algorithm.
+     *
+     * A digest is a fixed-length hash of the original data. It is often used
+     * to verify the integrity of the original data, or to create a
+     * "fingerprint" or "summary" of the original data that can be used to
+     * identify it.
+     *
+     * Cryptographic digests should exhibit collision-resistance, meaning that it's hard to
+     * come up with two different inputs that have the same digest value.
+     *
+     * @param algorithm names the algorithm to use.
+     * @param data the data to be digested
+     * @returns A promise that resolves with the digest value.
+     */
+    digest(
+        algorithm: HashAlgorithmIdentifier | Algorithm<HashAlgorithmIdentifier>,
+        data: ArrayBuffer | ArrayBufferView | DataView
+    ): Promise<ArrayBuffer>;
+
+    /**
+     * The `encrypt()` method encrypts data.
+     *
+     * @param algorithm defines the algorithm to use and any extra-parameters.
+     * @param key the key to use for encryption.
+     * @param data the data to encrypt (also known as "plaintext").
+     * @throws {InvalidAccessError} - if the provided key cannot be used for the encrypt operation.
+     * @throws {OperationError} - if the operation failed for an operation-specific reason.
+     * @returns A promise that resolves with the encrypted data (also known as "ciphertext").
+     */
+    encrypt(
+        algorithm: AesCtrParams | AesCbcParams | AesGcmParams,
+        key: CryptoKey,
+        data: ArrayBuffer | ArrayBufferView | DataView
+    ): Promise<ArrayBuffer>;
+
+    /**
+     * The `exportKey()` method exports a key: that is, it takes as input a `CryptoKey`
+     * object and gives you the key in an external, portable format.
+     *
+     * To export a key, the key must have `CryptoKey.extractable` set to `true`.
+     *
+     * @param format the format in which to export the key. Currently, only "raw" is supported.
+     * @param key the key to export.
+     * @throws {InvalidAccessError} - if the key is not extractable.
+     * @throws {NotSupportedError} - if the format is not supported.
+     * @throws {TypeError} - when trying to use an invalid format.
+     * @returns A promise that resolves with the exported key.
+     */
+    exportKey(
+        format: "raw",
+        key: CryptoKey
+    ): Promise<ArrayBuffer>;
+
+    /**
+     * Use the `generateKey()` method to generate a new key (for symmetric
+     * algorithms) or key pair (for public-key algorithms).
+     *
+     * @param algorithm defines the type of key to generate and providing extra algorithm-specific parameters.
+     * @param extractable indicates whether it will be possible to export the key using `SubtleCrypto.exportKey()` or `SubtleCrypto.wrapKey`.
+     * @param keyUsages indicates what can be done with the newly generated key.
+     * @throws {SyntaxError} - if the result is a `CryptoKey` of type `secret` or `private` but `keyUsages is empty.
+     * @returns A promise that resolves with the newly generated `CryptoKey` or `CryptoKeyPair`.
+     */
+    generateKey(
+        algorithm: AesKeyGenParams | HmacKeyGenParams,
+        extractable: boolean,
+        keyUsages: Array<"encrypt" | "decrypt" | "sign" | "verify">
+    ): Promise<CryptoKey>;
+
+    /**
+     * The `importKey()` method imports a key into a `CryptoKey` object.
+     * It takes as input a key in an external, portable format and gives you
+     * a `CryptoKey` object that can be used in the Web Crypto API.
+     *
+     * @param format the format of the key to import. Currently, only "raw" is supported.
+     * @param keyData the key data to import.
+     * @param algorithm defines the algorithm to use and any extra-parameters.
+     * @param extractable indicates whether it will be possible to export the key using `SubtleCrypto.exportKey()` or `SubtleCrypto.wrapKey`.
+     * @param keyUsages indicates what can be done with the newly generated key.
+     * @throws {SyntaxError} - if the result is a `CryptoKey` of type `secret` or `private` but `keyUsages is empty.
+     * @throws {TypeError} - when trying to use an invalid format or if the `keyData` is not suited for that format.
+     * @returns A promise that resolves with the imported `CryptoKey`.
+     */
+    importKey(
+        format: "raw",
+        keyData: ArrayBuffer | ArrayBufferView | DataView,
+        algorithm: "AES-CBC" | "AES-CTR" | "AES-GCM" | Algorithm<"AES-CBC" | "AES-CTR" | "AES-GCM"> | HmacImportParams,
+        extractable: boolean,
+        keyUsages: Array<"encrypt" | "decrypt" | "sign" | "verify">
+    ): Promise<CryptoKey>;
+
+    /**
+     * The `sign()` method generates a digital signature.
+     *
+     * It takes as its argument a key to sign with, some algorithm-identifier
+     * specific parameters, and the data to sign.
+     *
+     * @param algorithm defines the algorithm to use and any extra-parameters.
+     * @param key the key to use for signing. If `algorithm` identifies a public-key cryptosystem, this is the private key.
+     * @param data the data to sign.
+     * @throws {InvalidAccessError} - if the provided key cannot be used for the sign operation.
+     * @returns A promise that resolves with the signature.
+     */
+    sign(
+        algorithm: "HMAC" | Algorithm<"HMAC">,
+        key: CryptoKey,
+        data: ArrayBuffer | ArrayBufferView | DataView
+    ): Promise<ArrayBuffer>;
+
+    /**
+     * The `verify()` method verifies a digital signature.
+     *
+     * @param algorithm defines the algorithm to use and any extra-parameters.
+     * @param key the key to use for verifying. It is the secret key for a symmetric algorithm and the public key for a public-key system.
+     * @param signature the signature to verify.
+     * @param data the data to verify.
+     * @throws {InvalidAccessError} - if the provided key cannot be used for the verify operation.
+     * @returns A promise that resolves with a boolean indicating whether the signature is valid.
+     */
+    verify(
+        algorithm: "HMAC" | Algorithm<"HMAC">,
+        key: CryptoKey,
+        signature: ArrayBuffer | ArrayBufferView | DataView,
+        data: ArrayBuffer | ArrayBufferView | DataView
+    ): Promise<boolean>;
+}
+
+export interface CryptoKey {
+    /**
+     * The type of key the object represents.
+     */
+    readonly type: "secret" | "private" | "public";
+
+    /**
+     * A boolean value indicating whether or not the
+     * key may be extracted using `SubtleCrypto.exportKey()` or
+     * `SubtleCrypto.wrapKey()`.
+     */
+    readonly extractable: boolean;
+
+    /**
+     * An object describing the algorithm for which this key can be used
+     * and any associated extra parameters.
+     */
+    readonly algorithm: object;
+
+    /**
+     * An array of strings, indicating what can be done with the key.
+     */
+    readonly usages: Array<"encrypt" | "decrypt" | "sign" | "verify">;
+}
+
+/**
+ * The `Algorithm` dictionary of the Web Crypto API represents the
+ * object that should be passed as the `algorithm` parameter of
+ * most `SubtleCrypto` methods.
+ */
+export interface Algorithm<I extends AlgorithmIdentifier | HashAlgorithmIdentifier> {
+    /**
+     * The name of the algorithm to use.
+     */
+    name: I;
+}
+
+/**
+ * The `AlgorithmIdentifier` type of the Web Crypto API represents
+ * the name of an algorithm.
+ */
+export type AlgorithmIdentifier = string;
+
+/**
+ * The `HashAlgorithmIdentifier` type of the Web Crypto API represents
+ * the name of a hash algorithm.
+ */
+export type HashAlgorithmIdentifier = "SHA-1" | "SHA-256" | "SHA-384" | "SHA-512";
+
+/**
+ * The `AesKeyGenParams` dictionary of the Web Crypto API represents the
+ * object that should be passed as the `algorithm` parameter of the
+ * `SubtleCrypto.generateKey()` method when generating a new AES key.
+ */
+export interface AesKeyGenParams extends Algorithm<AlgorithmIdentifier> {
+    /**
+     * The name of the algorithm to use.
+     */
+    name: "AES-GCM" | "AES-CBC" | "AES-CTR" | "AES-CFB" | "AES-KW";
+
+    /**
+     * The length of the key, in bits.
+     */
+    length: 128 | 192 | 256;
+}
+
+/**
+ * The `AesCtrParams` dictionary of the Web Crypto API represents the
+ * object that should be passed as the `algorithm` parameter of the
+ * `SubtleCrypto.encrypt()` and `SubtleCrypto.decrypt()`, `SubtleCrypto.wrapKey()` and
+ * `SubtleCrypto.unwrapKey()` methods when using the AES-CTR algorithm.
+ */
+export interface AesCtrParams extends Algorithm<AlgorithmIdentifier> {
+    /**
+     * The name of the algorithm to use.
+     */
+    name: "AES-CTR";
+
+    /**
+     * The initial value of the counter block. This must be 16-byte
+     * long (the AES block size). The rightmost `length` bits of this
+     * block are used for the counter, and the rest is used for the
+     * nonce.
+     */
+    counter: ArrayBuffer | ArrayBufferView | DataView;
+
+    /**
+     * The number of bits in the counter block that are used for the actual
+     * counter. The counter must be big enough that it doesn't wrap. If the
+     * message is `n` blocks and the counter is `m` bits long, then the following
+     * must be true: `n < 2^m`.
+     */
+    length: number;
+}
+
+/**
+ * The `AesCbcParams` dictionary of the Web Crypto API represents the
+ * object that should be passed as the `algorithm` parameter of the
+ * `SubtleCrypto.encrypt()` and `SubtleCrypto.decrypt()`, `SubtleCrypto.wrapKey()` and
+ * `SubtleCrypto.unwrapKey()` methods when using the AES-CBC algorithm.
+ */
+export interface AesCbcParams extends Algorithm<AlgorithmIdentifier> {
+    /**
+     * The name of the algorithm to use.
+     */
+    name: "AES-CBC";
+
+    /**
+     * The initialization vector to use for the operation.
+     * This must be 16-byte long (the AES block size), unpredictable, and
+     * preferably cryptographically random. However, it is not required to be
+     * secret (it may be transmitted unencrypted along with the ciphertext).
+     */
+    iv: ArrayBuffer | ArrayBufferView | DataView;
+}
+
+/**
+ * The `AesGcmParams` dictionary of the Web Crypto API represents the
+ * object that should be passed as the `algorithm` parameter of the
+ * `SubtleCrypto.encrypt()` and `SubtleCrypto.decrypt()`, `SubtleCrypto.wrapKey()` and
+ * `SubtleCrypto.unwrapKey()` methods when using the AES-GCM algorithm.
+ */
+export interface AesGcmParams extends Algorithm<AlgorithmIdentifier> {
+    /**
+     * The name of the algorithm to use.
+     */
+    name: "AES-GCM";
+
+    /**
+     * The initialization vector to use for the operation.
+     * This must be 12-byte long (the GCM block size), unpredictable, and
+     * preferably cryptographically random. This must be unique for every
+     * encryption operation carried out with a given key. Put another way,
+     * never reuse an IV with the same key.
+     */
+    iv: ArrayBuffer | ArrayBufferView | DataView;
+
+    /**
+     * Contains additional data that will not be encrypted but will be
+     * authenticated. This is optional, and can be omitted if you don't
+     * need to pass any additional data. If `additionalData` is specified,
+     * then the same data must be given in the corresponding call to `decrypt()`.
+     * If the data is not the same, then the decryption will fail. This gives
+     * you a way to authenticate the data, without having to encrypt it.
+     */
+    additionalData?: ArrayBuffer | ArrayBufferView | DataView;
+
+    /**
+     * The length of the authentication tag, in bits. This must be of size
+     * 96.
+     */
+    tagLength?: number;
+}
+
+/**
+ * The `HmacKeyGenParams` dictionary of the Web Crypto API represents the
+ * object that should be passed as the `algorithm` parameter of the
+ * `SubtleCrypto.generateKey()` method when generating a new HMAC key.
+ */
+export interface HmacKeyGenParams extends Algorithm<AlgorithmIdentifier> {
+    /**
+     * The name of the algorithm to use.
+     */
+    name: "HMAC";
+
+    /**
+     * A string representing the name of the digest function to use.
+     */
+    hash: "SHA-1" | "SHA-256" | "SHA-384" | "SHA-512";
+
+    /**
+     * The length of the key, in bits. If the length is not specified,
+     * then the generated key will be as long as the block size of
+     * the hash function you have chosen. Unless you have a good reason
+     * to use a different length, omit this property and use the default.
+     */
+    length?: number;
+}
+
+/**
+ * The `HmacImportParams` dictionary of the Web Crypto API represents the
+ * object that should be passed as the `algorithm` parameter of the
+ * `SubtleCrypto.importKey()` method when importing an HMAC key.
+ */
+export interface HmacImportParams extends Algorithm<AlgorithmIdentifier> {
+    /**
+     * The name of the algorithm to use.
+     */
+    name: "HMAC";
+
+    /**
+     * The name of the digest function to use.
+     */
+    hash: HashAlgorithmIdentifier;
+
+    /**
+     * The length of the key, in bits. If the length is not specified,
+     * then the generated key will be as long as the block size of
+     * the hash function you have chosen. Unless you have a good reason
+     * to use a different length, omit this property and use the default.
+     */
+    length?: number;
+}
+
+/**
+ * The TypedArray interface represents an array-like view of an underlying
+ * binary data buffer. It is used to represent a generic, fixed-length
+ * raw binary data buffer. The ArrayBuffer that underlies a typed array
+ * can be accessed and modified by using the ArrayBufferView methods.
+ *
+ * Note that this type does not include Float32Array and Float64Array, which
+ * makes it differ from the ArrayBufferView type.
+ */
+export type TypedArray =
+    | Int8Array
+    | Uint8Array
+    | Uint8ClampedArray
+    | Int16Array
+    | Uint16Array
+    | Int32Array
+    | Uint32Array;

k6/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for k6 0.43
+// Type definitions for k6 0.44
 // Project: https://k6.io/docs/
 // Definitions by: na-- <https://github.com/na-->
 //                 Mihail Stoykov <https://github.com/MStoykov>
@@ -8,6 +8,7 @@
 //                 Oleg Bespalov <https://github.com/olegbespalov>
 //                 Pepe Cano <https://github.com/ppcano>
 //                 Nicole van der Hoeven <https://github.com/nicolevanderhoeven>
+//                 Ankur Agarwal <https://github.com/ankur22>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 3.9
 
@@ -41,9 +42,11 @@ import './html';
 import './http';
 import './metrics';
 import './options';
+import './experimental/browser';
 import './experimental/redis';
 import './experimental/timers';
 import './experimental/tracing';
+import './experimental/webcrypto';
 import './experimental/websockets';
 import './ws';
 import './net/grpc';

k6/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/k6",
-    "version": "0.43.3",
+    "version": "0.44.1",
     "description": "TypeScript definitions for k6",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/k6",
     "license": "MIT",
@@ -44,6 +44,11 @@
             "name": "Nicole van der Hoeven",
             "url": "https://github.com/nicolevanderhoeven",
             "githubUsername": "nicolevanderhoeven"
+        },
+        {
+            "name": "Ankur Agarwal",
+            "url": "https://github.com/ankur22",
+            "githubUsername": "ankur22"
         }
     ],
     "main": "",
@@ -55,6 +60,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "2cbfa702b37e2f3d5238d3b1b9b10788b402594bf74c75209901da48c302472c",
+    "typesPublisherContentHash": "682e46b4410e1338c96b7b05df4cb618809adceb3857d43f06b155bfbd799e21",
     "typeScriptVersion": "4.3"
 }