@types/k6 0.50.0 → 0.51.0

k6/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for k6 (https://grafana.com/docs/k6/lates
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/k6.
 
 ### Additional Details
- * Last updated: Mon, 25 Mar 2024 14:35:33 GMT
+ * Last updated: Mon, 13 May 2024 13:35:56 GMT
  * Dependencies: none
 
 # Credits

k6/experimental/browser.d.ts

@@ -643,6 +643,11 @@ export interface Browser {
         options?: NewBrowserContextOptions,
     ): Page;
 
+    /**
+     * Returns the browser application's user agent.
+     */
+    userAgent(): string;
+
     /**
      * Returns the browser application's version.
      */
@@ -1045,12 +1050,163 @@ export interface ElementHandle extends JSHandle {
      */
     boundingBox(): Rect;
 
+    /**
+     * Checks the checkbox element.
+     * @param options The options to use.
+     */
+    check(options?: ElementClickOptions & StrictnessOptions): void;
+
+    /**
+     * Clicks the element.
+     * @param options The options to use.
+     * @returns A promise that resolves when the element is clicked.
+     */
+    click(
+        options?: {
+            /**
+             * The mouse button (`left`, `middle` or `right`) to use during the action.
+             * Defaults to `left`.
+             */
+            button?: MouseButton;
+
+            /**
+             * The number of times the action is performed. Defaults to `1`.
+             */
+            clickCount?: number;
+
+            /**
+             * Milliseconds to wait between `mousedown` and `mouseup`. Defaults to `0`.
+             */
+            delay?: number;
+
+            /**
+             * Setting this to `true` will bypass the actionability checks (`visible`,
+             * `stable`, `enabled`). Defaults to `false`.
+             */
+            force?: boolean;
+
+            /**
+             * `Alt`, `Control`, `Meta` or `Shift` modifiers keys pressed during the
+             * action. If not specified, currently pressed modifiers are used,
+             * otherwise defaults to `null`.
+             */
+            modifiers?: KeyboardModifier[];
+
+            /**
+             * If set to `true` and a navigation occurs from performing this action, it
+             * will not wait for it to complete. Defaults to `false`.
+             */
+            noWaitAfter?: boolean;
+
+            /**
+             * A point to use relative to the top left corner of the element. If not
+             * supplied, a visible point of the element is used.
+             */
+            position?: {
+                x: number;
+
+                y: number;
+            };
+
+            /**
+             * Maximum time in milliseconds. Defaults to `30` seconds. Default is
+             * overridden by the `setDefaultTimeout` option on `BrowserContext` or
+             * `page` methods.
+             *
+             * Setting the value to `0` will disable the timeout.
+             */
+            timeout?: number;
+
+            /**
+             * Setting this to `true` will perform the actionability checks without
+             * performing the action. Useful to wait until the element is ready for the
+             * action without performing it. Defaults to `false`.
+             */
+            trial?: boolean;
+        },
+    ): Promise<void>;
+
     /**
      * Get the content frame for element handles.
      * @returns The content frame handle of the element handle.
      */
     contentFrame(): Frame;
 
+    /**
+     * Double clicks the element.
+     * @param options The options to use.
+     */
+    dblclick(
+        options?: {
+            /**
+             * The mouse button (`left`, `middle` or `right`) to use during the action.
+             * Defaults to `left`.
+             */
+            button?: MouseButton;
+
+            /**
+             * Milliseconds to wait between `mousedown` and `mouseup`. Defaults to `0`.
+             */
+            delay?: number;
+
+            /**
+             * Setting this to `true` will bypass the actionability checks (`visible`,
+             * `stable`, `enabled`). Defaults to `false`.
+             */
+            force?: boolean;
+
+            /**
+             * `Alt`, `Control`, `Meta` or `Shift` modifiers keys pressed during the
+             * action. If not specified, currently pressed modifiers are used,
+             * otherwise defaults to `null`.
+             */
+            modifiers?: KeyboardModifier[];
+
+            /**
+             * If set to `true` and a navigation occurs from performing this action, it
+             * will not wait for it to complete. Defaults to `false`.
+             */
+            noWaitAfter?: boolean;
+
+            /**
+             * A point to use relative to the top left corner of the element. If not
+             * supplied, a visible point of the element is used.
+             */
+            position?: {
+                x: number;
+
+                y: number;
+            };
+
+            /**
+             * Maximum time in milliseconds. Defaults to `30` seconds. Default is
+             * overridden by the `setDefaultTimeout` option on `BrowserContext` or
+             * `page` methods.
+             *
+             * Setting the value to `0` will disable the timeout.
+             */
+            timeout?: number;
+
+            /**
+             * Setting this to `true` will perform the actionability checks without
+             * performing the action. Useful to wait until the element is ready for the
+             * action without performing it. Defaults to `false`.
+             */
+            trial?: boolean;
+        },
+    ): void;
+
+    /**
+     * Dispatches a DOM event to the element.
+     * @param type DOM event type: `"click"` etc.
+     * @param eventInit Optional event-specific initialization properties.
+     * @param options
+     */
+    dispatchEvent(
+        type: string,
+        eventInit?: EvaluationArgument,
+    ): void;
+
     /**
      * Fill the `input` or `textarea` element with the provided `value`.
      * @param value Value to fill for the `input` or `textarea` element.
@@ -1207,7 +1363,7 @@ export interface ElementHandle extends JSHandle {
      * or at the specified position.
      * @param options Tap options.
      */
-    tap(options?: MouseMoveOptions): void;
+    tap(options?: MouseMoveOptions): Promise<void>;
 
     /**
      * Returns the `node.textContent`.
@@ -1321,7 +1477,7 @@ export interface Frame {
      * @param selector The selector to use.
      * @param options The options to use.
      */
-    tap(selector: string, options?: ElementClickOptions & KeyboardModifierOptions & StrictnessOptions): void;
+    tap(selector: string, options?: ElementClickOptions & KeyboardModifierOptions & StrictnessOptions): Promise<void>;
 
     /**
      * Press the given key for the first element found that matches the selector.
@@ -1660,7 +1816,7 @@ export interface JSHandle<T = any> {
     evaluateHandle<R, Arg>(pageFunction: PageFunction<Arg, R>, arg?: Arg): JSHandle<R>;
 
     /**
-     * Fethes a map with own property names of of the `JSHandle` with their values as
+     * Fetches a map with own property names of of the `JSHandle` with their values as
      * `JSHandle` instances.
      * @returns A map with property names as keys and `JSHandle` instances for the property values.
      */
@@ -1893,7 +2049,7 @@ export interface Locator {
      * Tap on the chosen element.
      * @param options Options to use.
      */
-    tap(options?: MouseMoveOptions): void;
+    tap(options?: MouseMoveOptions): Promise<void>;
 
     /**
      * Dispatches HTML DOM event types e.g. `click`.
@@ -3129,7 +3285,7 @@ export interface Page {
              */
             trial?: boolean;
         },
-    ): void;
+    ): Promise<void>;
 
     /**
      * **NOTE** Use locator-based locator.textContent([options]) instead.
@@ -3737,7 +3893,7 @@ export interface Touchscreen {
      * @param x The x position.
      * @param y The y position.
      */
-    tap(x: number, y: number): void;
+    tap(x: number, y: number): Promise<void>;
 }
 
 /**

k6/experimental/webcrypto.d.ts

@@ -91,24 +91,23 @@ export interface SubtleCrypto {
      *
      * 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" and "jwk" are supported.
+     * @param format the format in which to export the key.
      * @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" | "jwk", key: CryptoKey): Promise<ArrayBuffer | JWK>;
+    exportKey(format: "raw" | "jwk" | "spki" | "pkcs8", key: CryptoKey): Promise<ArrayBuffer | JWK>;
 
     /**
-     * Use the `generateKey()` method to generate a new key (for symmetric
-     * algorithms) or key pair (for public-key algorithms).
+     * Use the `generateKey()` method to generate a new key.
      *
      * @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`.
+     * @returns A promise that resolves with the newly generated `CryptoKey`.
      */
     generateKey(
         algorithm: AesKeyGenParams | HmacKeyGenParams,
@@ -116,12 +115,27 @@ export interface SubtleCrypto {
         keyUsages: Array<"encrypt" | "decrypt" | "sign" | "verify">,
     ): Promise<CryptoKey>;
 
+    /**
+     * Use the `generateKey()` method to generate a new key pair for asymmetric 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 CryptoKeyPair`.
+     */
+    generateKey(
+        algorithm: EcKeyGenParams,
+        extractable: boolean,
+        keyUsages: Array<"sign" | "verify" | "deriveKey" | "deriveBits">,
+    ): Promise<CryptoKeyPair>;
+
     /**
      * 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" and "jwk" are supported.
+     * @param format the format of the key to import.
      * @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`.
@@ -131,11 +145,17 @@ export interface SubtleCrypto {
      * @returns A promise that resolves with the imported `CryptoKey`.
      */
     importKey(
-        format: "raw" | "jwk",
+        format: "raw" | "jwk" | "spki" | "pkcs8",
         keyData: ArrayBuffer | ArrayBufferView | DataView | JWK,
-        algorithm: "AES-CBC" | "AES-CTR" | "AES-GCM" | Algorithm<"AES-CBC" | "AES-CTR" | "AES-GCM"> | HmacImportParams,
+        algorithm:
+            | "AES-CBC"
+            | "AES-CTR"
+            | "AES-GCM"
+            | Algorithm<"AES-CBC" | "AES-CTR" | "AES-GCM">
+            | HmacImportParams
+            | EcKeyImportParams,
         extractable: boolean,
-        keyUsages: Array<"encrypt" | "decrypt" | "sign" | "verify">,
+        keyUsages: Array<"encrypt" | "decrypt" | "sign" | "verify" | "deriveKey" | "deriveBits">,
     ): Promise<CryptoKey>;
 
     /**
@@ -151,7 +171,7 @@ export interface SubtleCrypto {
      * @returns A promise that resolves with the signature.
      */
     sign(
-        algorithm: "HMAC" | Algorithm<"HMAC">,
+        algorithm: "HMAC" | Algorithm<"HMAC"> | EcdsaParams,
         key: CryptoKey,
         data: ArrayBuffer | ArrayBufferView | DataView,
     ): Promise<ArrayBuffer>;
@@ -167,11 +187,24 @@ export interface SubtleCrypto {
      * @returns A promise that resolves with a boolean indicating whether the signature is valid.
      */
     verify(
-        algorithm: "HMAC" | Algorithm<"HMAC">,
+        algorithm: "HMAC" | Algorithm<"HMAC"> | EcdsaParams,
         key: CryptoKey,
         signature: ArrayBuffer | ArrayBufferView | DataView,
         data: ArrayBuffer | ArrayBufferView | DataView,
     ): Promise<boolean>;
+
+    /**
+     * The `deriveBits()` method derives an array of bits from a base key.
+     *
+     * @param algorithm defines the derivation algorithm to use.
+     * @param baseKey A `CryptoKey` representing the input to the derivation algorithm. Currently, only an ECDH private key is possible.
+     * @param length A number representing the number of bits to derive. Currently, the number should be a multiple of 8.
+     */
+    deriveBits(
+        algorithm: EcdhKeyDeriveParams,
+        baseKey: CryptoKey,
+        length?: number,
+    ): Promise<ArrayBuffer>;
 }
 
 export interface CryptoKey {
@@ -196,7 +229,27 @@ export interface CryptoKey {
     /**
      * An array of strings, indicating what can be done with the key.
      */
-    readonly usages: Array<"encrypt" | "decrypt" | "sign" | "verify">;
+    readonly usages: Array<"encrypt" | "decrypt" | "sign" | "verify" | "deriveKey" | "deriveBits">;
+}
+
+/**
+ * The `CryptoKeyPair` dictionary represents a key pair
+ * for an asymmetric cryptography algorithm,
+ * also known as a public-key algorithm.
+ */
+export interface CryptoKeyPair {
+    /**
+     * A `CryptoKey` object representing the private key.
+     * For encryption and decryption algorithms, this key is used to decrypt.
+     * For signing and verification algorithms it is used to sign.
+     */
+    readonly privateKey: CryptoKey;
+    /**
+     * A CryptoKey object representing the public key.
+     * For encryption and decryption algorithms, this key is used to encrypt.
+     * For signing and verification algorithms it is used to verify signatures.
+     */
+    readonly publicKey: CryptoKey;
 }
 
 /**
@@ -353,6 +406,26 @@ export interface HmacKeyGenParams extends Algorithm<AlgorithmIdentifier> {
     length?: number;
 }
 
+/**
+ * The EcKeyGenParams dictionary of the Web Crypto API represents the
+ * object that should be passed as the algorithm parameter into
+ * `SubtleCrypto.generateKey()`, when generating
+ *  any elliptic-curve-based key pair:
+ *  that is, when the algorithm is identified as either of ECDSA or ECDH.
+ */
+export interface EcKeyGenParams extends Algorithm<AlgorithmIdentifier> {
+    /**
+     * The name of the algorithm to use.
+     */
+    name: "ECDSA" | "ECDH";
+
+    /**
+     * The name of the elliptic curve to use.
+     * This may be any of the following names for NIST-approved curves.
+     */
+    namedCurve: "P-256" | "P-384" | "P-521";
+}
+
 /**
  * The `HmacImportParams` dictionary of the Web Crypto API represents the
  * object that should be passed as the `algorithm` parameter of the
@@ -378,6 +451,61 @@ export interface HmacImportParams extends Algorithm<AlgorithmIdentifier> {
     length?: number;
 }
 
+/**
+ * The `EcKeyImportParams` dictionary of the Web Crypto API represents
+ * the object that should be passed as the algorithm parameter
+ * into SubtleCrypto.importKey() or SubtleCrypto.unwrapKey(),
+ * when generating any elliptic-curve-based key pair:
+ * that is, when the algorithm is identified as either of ECDSA or ECDH.
+ */
+export interface EcKeyImportParams extends Algorithm<AlgorithmIdentifier> {
+    /**
+     * The name of the algorithm to use.
+     */
+    name: "ECDSA" | "ECDH";
+
+    /**
+     * The name of the elliptic curve to use.
+     * This may be any of the following names for NIST-approved curves.
+     */
+    namedCurve: "P-256" | "P-384" | "P-521";
+}
+
+/**
+ * The `EcdsaParams` dictionary of the Web Crypto API represents
+ * the object that should be passed as the algorithm parameter
+ * into SubtleCrypto.sign() or SubtleCrypto.verify()
+ * when using the ECDSA algorithm.
+ */
+export interface EcdsaParams extends Algorithm<AlgorithmIdentifier> {
+    /**
+     * The name of the algorithm to use.
+     */
+    name: "ECDSA";
+
+    /**
+     * An identifier for the digest algorithm to use.
+     */
+    hash: "SHA-1" | "SHA-256" | "SHA-384" | "SHA-512";
+}
+
+/**
+ * The `EcdhKeyDeriveParams` dictionary of the Web Crypto API represents
+ * the object that should be passed as the algorithm parameter
+ * into `SubtleCrypto.deriveKey()`, when using the ECDH algorithm.
+ */
+export interface EcdhKeyDeriveParams extends Algorithm<AlgorithmIdentifier> {
+    /**
+     * The name of the algorithm to use. Only the "ECDH" value is possible.
+     */
+    name: "ECDH";
+
+    /**
+     * A `CryptoKey` object representing the public key of the other entity.
+     */
+    public: CryptoKey;
+}
+
 /**
  * The TypedArray interface represents an array-like view of an underlying
  * binary data buffer. It is used to represent a generic, fixed-length

k6/experimental/websockets.d.ts

@@ -180,7 +180,7 @@ export enum BinaryType {
     /**
      * Binary data is returned in ArrayBuffer form. k6 supports only this type.
      */
-    ArrayBuffer = "ArrayBuffer",
+    ArrayBuffer = "arraybuffer",
 }
 
 /**

k6/index.d.ts

@@ -35,7 +35,6 @@ import "./experimental/timers";
 import "./experimental/tracing";
 import "./experimental/webcrypto";
 import "./experimental/websockets";
-import "./experimental/grpc";
 import "./timers";
 import "./ws";
 import "./net/grpc";

k6/net/grpc.d.ts

@@ -121,6 +121,9 @@ declare namespace grpc {
         /** Invokes an unary RPC request. */
         invoke(url: string, request: object, params?: Params): Response;
 
+        /** Asynchronously invokes an unary RPC request. */
+        asyncInvoke(url: string, request: object, params?: Params): Promise<Response>;
+
         /** Close the connection. */
         close(): void;
     }

k6/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/k6",
-    "version": "0.50.0",
+    "version": "0.51.0",
     "description": "TypeScript definitions for k6",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/k6",
     "license": "MIT",
@@ -60,6 +60,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "4ce3b8afa738b9a5dc17ab2f6215988fae6db390db3e895f7517086b6d109983",
+    "typesPublisherContentHash": "fd17fedc4161ea6cdb1d78db41100cc597d5c251769b71a824af1faaabbe4ff1",
     "typeScriptVersion": "4.7"
 }

k6/experimental/grpc.d.ts

@@ -1,205 +0,0 @@
-// === Response ===
-// ----------------
-
-/**
- * gRPC response.
- */
-export interface Response {
-    status: number;
-
-    message: object;
-
-    headers: object;
-
-    trailers: object;
-
-    error: object;
-}
-
-export interface ConnectParams {
-    /**
-     * If `true` will connect to the gRPC server using plaintext i.e. insecure.
-     */
-    plaintext?: boolean;
-
-    /**
-     * If `true` connection will try to use the gRPC server reflection protocol.
-     * https://github.com/grpc/grpc/blob/master/doc/server-reflection.md
-     */
-    reflect?: boolean;
-
-    /**
-     * Metadata to send with reflection request.
-     */
-    reflectMetadata?: object;
-
-    /**
-     * Connection timeout to use.
-     */
-    timeout?: string | number;
-
-    /**
-     *  Maximum message size in bytes the client can receive.
-     */
-    maxReceiveSize?: number;
-
-    /**
-     * Maximum message size in bytes the client can send.
-     */
-    maxSendSize?: number;
-
-    /**
-     * TLS settings of the connection.
-     */
-    tls?: TLSParams;
-}
-
-export interface TLSParams {
-    /**
-     *  PEM formatted client certificate.
-     */
-    cert: string;
-
-    /**
-     * PEM formatted client private key.
-     */
-    key: string;
-
-    /**
-     * Password for decrypting the client's private key.
-     */
-    password?: string;
-
-    /**
-     * PEM formatted string/strings of the certificate authorities.
-     */
-    cacerts?: string | string[];
-}
-
-export interface Params {
-    /**
-     * @deprecated Use metadata instead.
-     */
-    headers?: object;
-
-    metadata?: object;
-
-    tags?: object;
-
-    timeout?: string | number;
-}
-
-export interface GrpcError {
-    code: number;
-    details: string[] | object[];
-    message: string;
-}
-
-/**
- * This module provides classes for Remote Procedure Calls over HTTP/2.
- * https://grafana.com/docs/k6/latest/javascript-api/k6-experimental/grpc/
- *
- * @deprecated Use the `k6/net/grpc` module instead.
- */
-declare namespace grpc {
-    /**
-     * gRPC client to interact with a gRPC server.
-     * https://grafana.com/docs/k6/latest/javascript-api/k6-experimental/grpc/client/
-     *
-     * @deprecated Use the `k6/net/grpc` module instead.
-     */
-    class Client {
-        protected __brand: never;
-
-        constructor();
-
-        /** Opens a connection to a gRPC server. */
-        connect(address: string, params?: ConnectParams): void;
-
-        /** Loads and parses the protocol buffer descriptors. */
-        load(importPaths: string[], ...protoFiles: string[]): void;
-
-        /** Loads a protoset and parses the protocol buffer descriptors */
-        loadProtoset(protosetPath: string): void;
-
-        /** Invokes an unary RPC request. */
-        invoke(url: string, request: object, params?: Params): Response;
-
-        /** Close the connection. */
-        close(): void;
-    }
-
-    /**
-     * StreamEvent describes the possible events that can be emitted
-     * by a gRPC stream.
-     */
-    type StreamEvent =
-        /**
-         * Event fired when data has been received from the server.
-         */
-        | "data"
-        /**
-         * Event fired when a stream has been closed due to an error.
-         */
-        | "error"
-        /**
-         * Event fired when the stream closes.
-         */
-        | "end";
-
-    /**
-     * Stream allows you to use streaming RPCs.
-     *
-     * @deprecated Use the `k6/net/grpc` module instead.
-     */
-    class Stream {
-        /**
-         * The gRPC stream constructor, representing a single gRPC stream.
-         *
-         * @param client - the gRPC client to use, it must be connected.
-         * @param url - the RPC method to call.
-         * @param params - the parameters to use for the RPC call.
-         */
-        constructor(client: Client, url: string, params?: Params);
-
-        /**
-         * Set up handler functions for various events on the gRPC stream.
-         *
-         * @param event - the event to listen for
-         * @param listener - the callback to invoke when the event is emitted
-         */
-        on(event: StreamEvent, listener: (data: object | GrpcError | undefined) => void): void;
-
-        /**
-         * Writes a request to the stream.
-         *
-         * @param request - the request (message) to send to the server
-         */
-        write(request: object): void;
-
-        /**
-         * Signals to the server that the client has finished sending messages.
-         */
-        end(): void;
-    }
-
-    const StatusOK: number;
-    const StatusCanceled: number;
-    const StatusUnknown: number;
-    const StatusInvalidArgument: number;
-    const StatusDeadlineExceeded: number;
-    const StatusNotFound: number;
-    const StatusAlreadyExists: number;
-    const StatusPermissionDenied: number;
-    const StatusResourceExhausted: number;
-    const StatusFailedPrecondition: number;
-    const StatusAborted: number;
-    const StatusOutOfRange: number;
-    const StatusUnimplemented: number;
-    const StatusInternal: number;
-    const StatusUnavailable: number;
-    const StatusDataLoss: number;
-    const StatusUnauthenticated: number;
-}
-
-export default grpc;