@types/k6 0.53.1 → 0.54.0

k6/{http.d.ts → http/index.d.ts}

@@ -1,5 +1,5 @@
-import { JSONValue } from ".";
-import { Selection } from "./html";
+import { Selection } from "../html/index.js";
+import { JSONValue } from "../index.js";
 
 /**
  * Make DELETE  request.
@@ -143,6 +143,17 @@ export function asyncRequest<RT extends ResponseType | undefined>(
     params?: RefinedParams<RT> | null,
 ): Promise<RefinedResponse<RT>>;
 
+/**
+ * Creates a URL with set name tag.
+ * https://grafana.com/docs/k6/latest/using-k6/http-requests/#url-grouping
+ * @param strings - Passed string values.
+ * @param args - Tagged template expressions.
+ * @returns HTTP URL object.
+ * @example
+ * http.get(http.url`http://example.com/posts/${id}`) // tags.name="http://example.com/posts/${}",
+ */
+export function url(strings: TemplateStringsArray, ...args: Array<string | number | boolean>): HttpURL;
+
 /**
  * Batch multiple HTTP requests together,
  * to issue them in parallel over multiple TCP connections.
@@ -792,228 +803,4 @@ interface HttpURL {
     __brand: "http-url";
 }
 
-/**
- * The http module contains functionality for performing HTTP transactions.
- * https://grafana.com/docs/k6/latest/javascript-api/k6-http/
- */
-declare namespace http {
-    /**
-     * Make DELETE  request.
-     * https://grafana.com/docs/k6/latest/javascript-api/k6-http/del/
-     * @param url - Request URL.
-     * @param body - Discouraged. Request body. Object form encoded.
-     * @param params - Request parameters.
-     * @returns Resulting response.
-     */
-    function del<RT extends ResponseType | undefined>(
-        url: string | HttpURL,
-        body?: RequestBody | null,
-        params?: RefinedParams<RT> | null,
-    ): RefinedResponse<RT>;
-
-    /**
-     * Make HEAD request.
-     * https://grafana.com/docs/k6/latest/javascript-api/k6-http/head/
-     * @param url - Request URL.
-     * @param params - Request parameters.
-     * @returns Resulting response.
-     * @example
-     * http.head('https://test.k6.io')
-     */
-    function head<RT extends ResponseType | undefined>(
-        url: string | HttpURL,
-        params?: RefinedParams<RT> | null,
-    ): RefinedResponse<RT>;
-
-    /**
-     * Make GET request.
-     * https://grafana.com/docs/k6/latest/javascript-api/k6-http/get/
-     * @param url - Request URL.
-     * @param params - Request parameters.
-     * @returns Resulting response.
-     * @example
-     * http.get('https://k6.io')
-     */
-    function get<RT extends ResponseType | undefined>(
-        url: string | HttpURL,
-        params?: RefinedParams<RT> | null,
-    ): RefinedResponse<RT>;
-
-    /**
-     * Make OPTIONS request.
-     * https://grafana.com/docs/k6/latest/javascript-api/k6-http/options/
-     * @param url - Request URL.
-     * @param body - Request body. Object form encoded.
-     * @param params - Request parameters.
-     * @returns Resulting response.
-     */
-    function options<RT extends ResponseType | undefined>(
-        url: string | HttpURL,
-        body?: RequestBody | null,
-        params?: RefinedParams<RT> | null,
-    ): RefinedResponse<RT>;
-
-    /**
-     * Make PATCH request.
-     * https://grafana.com/docs/k6/latest/javascript-api/k6-http/patch/
-     * @param url - Request URL.
-     * @param body - Request body. Object form encoded.
-     * @param params - Request parameters.
-     * @returns Resulting response.
-     */
-    function patch<RT extends ResponseType | undefined>(
-        url: string | HttpURL,
-        body?: RequestBody | null,
-        params?: RefinedParams<RT> | null,
-    ): RefinedResponse<RT>;
-
-    /**
-     * Make POST request.
-     * https://grafana.com/docs/k6/latest/javascript-api/k6-http/post/
-     * @param url - Request URL.
-     * @param body - Request body. Object form encoded.
-     * @param params - Request parameters.
-     * @returns Resulting response.
-     * @example
-     * let formData = {name: 'k6'};
-     * let headers = { 'Content-Type': 'application/x-www-form-urlencoded' };
-     * http.post(url, formData, { headers: headers });
-     */
-    function post<RT extends ResponseType | undefined>(
-        url: string | HttpURL,
-        body?: RequestBody | null,
-        params?: RefinedParams<RT> | null,
-    ): RefinedResponse<RT>;
-
-    /**
-     * Make PUT request.
-     * https://grafana.com/docs/k6/latest/javascript-api/k6-http/put/
-     * @param url - Request URL.
-     * @param body - Request body. Object form encoded.
-     * @param params - Request parameters.
-     * @returns Resulting response.
-     */
-    function put<RT extends ResponseType | undefined>(
-        url: string | HttpURL,
-        body?: RequestBody | null,
-        params?: RefinedParams<RT> | null,
-    ): RefinedResponse<RT>;
-
-    /**
-     * Make request.
-     * https://grafana.com/docs/k6/latest/javascript-api/k6-http/request/
-     * @param method - HTTP method.
-     * @param url - Request URL.
-     * @param body - Request body. Object form encoded.
-     * @param params - Request parameters.
-     * @returns Resulting response.
-     * @example
-     * let formData = {name: 'k6'};
-     * let headers = { 'Content-Type': 'application/x-www-form-urlencoded' };
-     * http.request('POST', url, formData, { headers: headers });
-     */
-    function request<RT extends ResponseType | undefined>(
-        method: string,
-        url: string | HttpURL,
-        body?: RequestBody | null,
-        params?: RefinedParams<RT> | null,
-    ): RefinedResponse<RT>;
-
-    /**
-     * Make async request.
-     * https://grafana.com/docs/k6/latest/javascript-api/k6-http/asyncrequest/
-     * @param method - HTTP method.
-     * @param url - Request URL.
-     * @param body - Request body. Object form encoded.
-     * @param params - Request parameters.
-     * @returns Resulting response.
-     * @example
-     * let formData = {name: 'k6'};
-     * let headers = { 'Content-Type': 'application/x-www-form-urlencoded' };
-     * http.asyncRequest('POST', url, formData, { headers: headers });
-     */
-    function asyncRequest<RT extends ResponseType | undefined>(
-        method: string,
-        url: string | HttpURL,
-        body?: RequestBody | null,
-        params?: RefinedParams<RT> | null,
-    ): Promise<RefinedResponse<RT>>;
-
-    /**
-     * Creates a URL with set name tag.
-     * https://grafana.com/docs/k6/latest/using-k6/http-requests/#url-grouping
-     * @param strings - Passed string values.
-     * @param args - Tagged template expressions.
-     * @returns HTTP URL object.
-     * @example
-     * http.get(http.url`http://example.com/posts/${id}`) // tags.name="http://example.com/posts/${}",
-     */
-    function url(strings: TemplateStringsArray, ...args: Array<string | number | boolean>): HttpURL;
-
-    /**
-     * Batch multiple HTTP requests together,
-     * to issue them in parallel over multiple TCP connections.
-     * https://grafana.com/docs/k6/latest/javascript-api/k6-http/batch/
-     * @param requests - Request specifications.
-     * @returns Resulting responses.
-     * @example
-     * let req1 = {
-     *    method: 'GET',
-     *    url: 'https://httpbin.org/get',
-     * };
-     * let req2 = {
-     *   method: 'POST',
-     *   url: 'https://httpbin.org/post',
-     *   body: {
-     *     hello: 'world!',
-     *   },
-     *   params: {
-     *     headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-     *   },
-     * };
-     * let responses = http.batch([req1, req2]);
-     */
-    function batch<Q extends BatchRequests>(requests: Q): BatchResponses<Q>;
-
-    /**
-     * Create a file object used for building multipart requests (file uploads).
-     * https://grafana.com/docs/k6/latest/javascript-api/k6-http/file/
-     * @param data - File data.
-     * @param filename - Filename. Included in MIME message.
-     * @param contentType - Content type. Included in MIME message.
-     * @returns File data object.
-     * @example
-     * let binFile = open('/path/to/file.bin', 'b');
-     *
-     * export default function() {
-     *   let f = http.file(binFile, 'test.bin');
-     *   console.log(md5(f.data, 'hex'));
-     *   console.log(f.filename);
-     *   console.log(f.content_type);
-     * }
-     */
-    function file(data: string | ArrayBuffer, filename?: string, contentType?: string): FileData;
-
-    /**
-     * Get active cookie jar.
-     * https://grafana.com/docs/k6/latest/javascript-api/k6-http/cookiejar/
-     * @returns Active cookie jar.
-     * @example
-     * let jar = http.cookieJar();
-     */
-    function cookieJar(): CookieJar;
-    /**
-     * Returns a callback to be used with setResponseCallback to mark responses
-     * as expected based only on their status codes.
-     * https://staging.k6.io/docs/javascript-api/k6-http/expectedstatuses-statuses/
-     */
-    function expectedStatuses(...param: Array<number | ExpectedStatusesObject>): ExpectedStatusesCallback;
-
-    /**
-     * Set the response callback to be called to determine if a response was expected/successful or not.
-     * https://grafana.com/docs/k6/latest/javascript-api/k6-http/setresponsecallback/
-     */
-    function setResponseCallback(responseCallback: ExpectedStatusesCallback): void;
-}
-
-export default http;
+export * as default from "k6/http";

k6/index.d.ts

@@ -17,28 +17,7 @@
  * @packageDocumentation
  */
 
-import "./global"; // Type global environment
-
-// Expose everything to autoimport
-import "./browser";
-import "./crypto";
-import "./data";
-import "./encoding";
-import "./execution";
-import "./html";
-import "./http";
-import "./metrics";
-import "./options";
-import "./experimental/browser";
-import "./experimental/fs";
-import "./experimental/redis";
-import "./experimental/timers";
-import "./experimental/tracing";
-import "./experimental/webcrypto";
-import "./experimental/websockets";
-import "./timers";
-import "./ws";
-import "./net/grpc";
+import "./global.js"; // Type global environment
 
 // === Main ===
 // ------------
@@ -143,3 +122,5 @@ export interface JSONArray extends Array<JSONValue> {}
 export interface JSONObject {
     [key: string]: JSONValue;
 }
+
+export * as default from "k6";

k6/net/grpc/index.d.ts

@@ -0,0 +1,218 @@
+// === 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 {
+    /**
+     * Object with key-value pairs representing custom metadata the user would like to add to the request.
+     */
+    metadata?: object;
+
+    /**
+     * Key-value pairs where the keys are names of tags and the values are tag values
+     */
+    tags?: object;
+
+    /**
+     * Request timeout to use.
+     */
+    timeout?: string | number;
+
+    /**
+     * Specify if response messages should be discarded.
+     */
+    discardResponseMessage?: boolean;
+}
+
+export interface GrpcError {
+    code: number;
+    details: string[] | object[];
+    message: string;
+}
+
+/**
+ * gRPC client to interact with a gRPC server.
+ * https://grafana.com/docs/k6/latest/javascript-api/k6-net-grpc/client/
+ */
+export 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;
+
+    /** Asynchronously invokes an unary RPC request. */
+    asyncInvoke(url: string, request: object, params?: Params): Promise<Response>;
+
+    /** Close the connection. */
+    close(): void;
+}
+
+/**
+ * StreamEvent describes the possible events that can be emitted
+ * by a gRPC stream.
+ */
+export 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";
+
+/**
+ * StreamMessageMetadata handles gRPC stream messages's metadata
+ */
+export interface StreamMessageMetadata {
+    /**
+     * Contains the timestamp of the original event (for example, when a message has been received).
+     */
+    ts: number;
+}
+
+/**
+ * Stream allows you to use streaming RPCs.
+ */
+export 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, metadata: StreamMessageMetadata) => 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;
+}
+
+export const StatusOK: number;
+export const StatusCanceled: number;
+export const StatusUnknown: number;
+export const StatusInvalidArgument: number;
+export const StatusDeadlineExceeded: number;
+export const StatusNotFound: number;
+export const StatusAlreadyExists: number;
+export const StatusPermissionDenied: number;
+export const StatusResourceExhausted: number;
+export const StatusFailedPrecondition: number;
+export const StatusAborted: number;
+export const StatusOutOfRange: number;
+export const StatusUnimplemented: number;
+export const StatusInternal: number;
+export const StatusUnavailable: number;
+export const StatusDataLoss: number;
+export const StatusUnauthenticated: number;
+
+export * as default from "k6/net/grpc";

k6/{options.d.ts → options/index.d.ts}

@@ -3,7 +3,7 @@
  * https://grafana.com/docs/k6/latest/using-k6/k6-options/
  */
 
-import { CipherSuite } from "./http";
+import { CipherSuite } from "k6/http";
 
 /**
  * Program options.

k6/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/k6",
-    "version": "0.53.1",
+    "version": "0.54.0",
     "description": "TypeScript definitions for k6",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/k6",
     "license": "MIT",
@@ -51,6 +51,7 @@
             "url": "https://github.com/joanlopez"
         }
     ],
+    "type": "module",
     "main": "",
     "types": "index.d.ts",
     "repository": {
@@ -60,6 +61,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "51f2f592838cc27d3b1784aa8140db6d7c0e256577c0d8f960419afa871ee531",
+    "typesPublisherContentHash": "117f96c1bd174240bb9f518388a69fc69bbb14dd874730e2db3ea53c0513b9c6",
     "typeScriptVersion": "4.8"
 }

k6/{ws.d.ts → ws/index.d.ts}

@@ -1,4 +1,4 @@
-import { CookieJar } from "./http";
+import { CookieJar } from "k6/http";
 
 /**
  * Open WebSocket connection.
@@ -280,43 +280,4 @@ export abstract class WebSocketError {
     error(): string;
 }
 
-/**
- * This module provides a WebSocket client implementing the WebSocket protocol.
- * https://grafana.com/docs/k6/latest/javascript-api/k6-ws/
- */
-declare namespace ws {
-    /**
-     * Open WebSocket connection.
-     * https://grafana.com/docs/k6/latest/javascript-api/k6-ws/connect/
-     * @param url - Request URL.
-     * @param callback - Logic to execute with socket.
-     * @returns HTTP response to connection request.
-     * @example
-     * let res = ws.connect(url, function(socket) {
-     *   socket.on('open', function() {
-     *     console.log('WebSocket connection established!');
-     *     socket.close();
-     *   });
-     * });
-     */
-    function connect(url: string, callback: Executor): Response;
-
-    /**
-     * Open WebSocket connection.
-     * https://grafana.com/docs/k6/latest/javascript-api/k6-ws/connect/
-     * @param url - Request URL.
-     * @param params - Request parameters.
-     * @param callback - Logic to execute with socket.
-     * @returns HTTP response to connection request.
-     * @example
-     * let res = ws.connect(url, { param1: true } , function(socket) {
-     *   socket.on('open', function() {
-     *     console.log('WebSocket connection established!');
-     *     socket.close();
-     *   });
-     * });
-     */
-    function connect(url: string, params: Params | null, callback: Executor): Response;
-}
-
-export default ws;
+export * as default from "k6/ws";

k6/encoding.d.ts

@@ -1,90 +0,0 @@
-/**
- * Base64 decode a string.
- * https://grafana.com/docs/k6/latest/javascript-api/k6-encoding/b64decode/
- * @param input - The string to base64 decode.
- * @param encoding - Base64 variant.
- * @returns The base64 decoded version of the input string in either string or ArrayBuffer format, depending on the `format` parameter.
- * @example
- * encoding.b64decode(str)
- * encoding.b64decode(str, 'rawstd')
- * const decBuffer = encoding.b64decode(str, 'rawurl')
- * let decBin = new Uint8Array(decBuffer);
- */
-export function b64decode(input: string, encoding?: Base64Variant): ArrayBuffer;
-
-/**
- * Base64 decode a string.
- * https://grafana.com/docs/k6/latest/javascript-api/k6-encoding/b64decode/
- * @param input - The string to base64 decode.
- * @param encoding - Base64 variant.
- * @param format - If 's' return the data as a string, otherwise an ArrayBuffer object .
- * @returns The base64 decoded version of the input string in either string or ArrayBuffer format, depending on the `format` parameter.
- * @example
- * encoding.b64decode(str)
- * encoding.b64decode(str, 'rawstd')
- * const decodedString = encoding.b64decode(str, 'rawurl', 's')
- */
-export function b64decode(input: string, encoding: Base64Variant, format: "s"): string;
-
-/**
- * Base64 encode a string.
- * https://grafana.com/docs/k6/latest/javascript-api/k6-encoding/b64encode/
- * @param input - String to encode or ArrayBuffer object.
- * @param encoding - Base64 variant.
- * @returns Base64 encoded string.
- * @example
- * encoding.b64encode(str)
- * encoding.b64encode(str, 'rawstd')
- */
-export function b64encode(input: string | ArrayBuffer, encoding?: Base64Variant): string;
-
-/**
- * Base64 variant.
- */
-export type Base64Variant = "std" | "rawstd" | "url" | "rawurl";
-
-/**
- * The encoding module provides base64 encoding/decoding.
- * https://grafana.com/docs/k6/latest/javascript-api/k6-encoding/
- */
-declare namespace encoding {
-    /**
-     * Base64 decode a string.
-     * https://grafana.com/docs/k6/latest/javascript-api/k6-encoding/b64decode/
-     * @param input - The string to base64 decode.
-     * @param encoding - Base64 variant.
-     * @returns The base64 decoded version of the input string in either string or ArrayBuffer format, depending on the `format` parameter.
-     * @example
-     * encoding.b64decode(str)
-     * encoding.b64decode(str, 'rawstd')
-     * const decBuffer = encoding.b64decode(str, 'rawurl')
-     * let decBin = new Uint8Array(decBuffer);
-     */
-    function b64decode(input: string, encoding?: Base64Variant): ArrayBuffer;
-    /**
-     * Base64 decode a string.
-     * https://grafana.com/docs/k6/latest/javascript-api/k6-encoding/b64decode/
-     * @param input - The string to base64 decode.
-     * @param encoding - Base64 variant.
-     * @param format - If 's' return the data as a string, otherwise an ArrayBuffer object .
-     * @returns The base64 decoded version of the input string in either string or ArrayBuffer format, depending on the `format` parameter.
-     * @example
-     * encoding.b64decode(str)
-     * encoding.b64decode(str, 'rawstd')
-     * const decodedString = encoding.b64decode(str, 'rawurl', 's')
-     */
-    function b64decode(input: string, encoding: Base64Variant, format: "s"): string;
-    /**
-     * Base64 decode a string.
-     * https://grafana.com/docs/k6/latest/javascript-api/k6-encoding/b64decode/
-     * @param input - Base64 encoded string or ArrayBuffer object.
-     * @param encoding - Base64 variant.
-     * @returns Decoded string.
-     * @example
-     * encoding.b64encode(str)
-     * encoding.b64encode(str, 'rawstd')
-     */
-    function b64encode(input: string | ArrayBuffer, encoding?: Base64Variant): string;
-}
-
-export default encoding;