@types/k6 0.44.3 → 0.45.1

k6/experimental/grpc.d.ts

@@ -0,0 +1,154 @@
+// === Response ===
+// ----------------
+
+/**
+ * gRPC response.
+ */
+export interface Response {
+    status: number;
+
+    message: object;
+
+    headers: object;
+
+    trailers: object;
+
+    error: object;
+}
+
+export interface ConnectParams {
+    plaintext?: boolean;
+
+    reflect?: boolean;
+
+    timeout?: string | number;
+
+    maxReceiveSize?: number;
+
+    maxSendSize?: number;
+}
+
+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://k6.io/docs/javascript-api/k6-experimental/grpc/
+ */
+declare namespace grpc {
+    /**
+     * gRPC client to interact with a gRPC server.
+     * https://k6.io/docs/javascript-api/k6-experimental/grpc/client/
+     */
+    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.
+     */
+    enum StreamEvent {
+        /**
+         * Event fired when data has been received from the server.
+         */
+        Data = 'data',
+
+        /**
+         * Event fired when a stream has been closed due to an error.
+         */
+        Error = 'error',
+
+        /**
+         * Event fired when the stream closes.
+         */
+        End = 'end',
+    }
+
+    /**
+     * Stream allows you to use streaming RPCs.
+     */
+    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;

k6/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for k6 0.44
+// Type definitions for k6 0.45
 // Project: https://k6.io/docs/
 // Definitions by: na-- <https://github.com/na-->
 //                 Mihail Stoykov <https://github.com/MStoykov>
@@ -48,6 +48,7 @@ import './experimental/timers';
 import './experimental/tracing';
 import './experimental/webcrypto';
 import './experimental/websockets';
+import './experimental/grpc';
 import './ws';
 import './net/grpc';
 

k6/options.d.ts

@@ -242,6 +242,9 @@ export abstract class BaseScenario {
 
     /** Tags specific to this scenario. */
     tags?: { [name: string]: string };
+
+    /** Additional options for each scenario */
+    options?: ScenarioOptions;
 }
 
 /**
@@ -439,3 +442,8 @@ export type Scenario =
     | ConstantArrivalRateScenario
     | RampingArrivalRateScenario
     | ExternallyControlledScenario;
+
+export interface ScenarioOptions {
+    /** Browser specific options */
+    browser?: any;
+}

k6/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/k6",
-    "version": "0.44.3",
+    "version": "0.45.1",
     "description": "TypeScript definitions for k6",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/k6",
     "license": "MIT",
@@ -60,6 +60,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "361534b19bc50893282724e8e2785b8c69f23e9233af269e95c9050d7957d763",
+    "typesPublisherContentHash": "8c673ad1e0d421c8e8a0e61e19b53e64f4a57f91fc024601b5db8bc5742e7d73",
     "typeScriptVersion": "4.3"
 }

k6/experimental/browser/element_handle.d.ts

@@ -1,213 +0,0 @@
-import {
-    Rect,
-    ElementHandlePointerOptions,
-    ElementClickOptions,
-    KeyboardModifierOptions,
-    TimeoutOptions,
-    KeyboardPressOptions,
-    ScreenshotOptions,
-    ElementHandleOptions,
-    MouseMoveOptions,
-    StrictnessOptions,
-    InputElementState,
-    ElementState,
-    SelectOptionsObject,
-} from './';
-import { JSHandle } from './js_handle';
-import { Frame } from './frame';
-
-/**
- * ElementHandle represents an in-page DOM element.
- */
-export class ElementHandle extends JSHandle {
-    /**
-     * Finds an element matching the specified selector in the `ElementHandle`'s subtree.
-     * @param selector A selector to query element for.
-     * @returns An `ElementHandle` pointing to the result element or `null`.
-     */
-    $(selector: string): ElementHandle | null;
-
-    /**
-     * Finds all elements matching the specified selector in the `ElementHandle`'s subtree.
-     * @param selector A selector to query element for.
-     * @returns A list of `ElementHandle`s pointing to the result elements.
-     */
-    $$(selector: string): ElementHandle[];
-
-    /**
-     * This method returns the bounding box of the element.
-     * @returns Element's bounding box.
-     */
-    boundingBox(): Rect;
-
-    /**
-     * Get the content frame for element handles.
-     * @returns The content frame handle of the element handle.
-     */
-    contentFrame(): Frame;
-
-    /**
-     * Fill the `input` or `textarea` element with the provided `value`.
-     * @param value Value to fill for the `input` or `textarea` element.
-     * @param options Element handle options.
-     */
-    fill(value: string, options?: ElementHandleOptions): void;
-
-    /**
-     * Focuses the element.
-     */
-    focus(): void;
-
-    /**
-     * Fetch the element's attribute value.
-     * @param name Attribute name to get the value for.
-     * @returns Attribute value.
-     */
-    getAttribute(name: string): string | null;
-
-    /**
-     * Scrolls element into view and hovers over its center point.
-     * @param options Hover options.
-     */
-    hover(options?: ElementClickOptions & KeyboardModifierOptions): void;
-
-    /**
-     * Returns the `element.innerHTML`.
-     * @returns Element's innerHTML.
-     */
-    innerHTML(): string;
-
-    /**
-     * Returns the `element.innerText`.
-     * @returns Element's innerText.
-     */
-    innerText(): string;
-
-    /**
-     * Returns `input.value` for the selected `input`, `textarea` or `select` element.
-     * @returns The input value of the element.
-     */
-    inputValue(options?: TimeoutOptions): string;
-
-    /**
-     * Checks if a checkbox or radio is checked.
-     * @returns Whether the element is checked.
-     */
-    isChecked(): boolean;
-
-    /**
-     * Checks if the element is disabled.
-     * @returns Whether the element is disabled.
-     */
-    isDisabled(): boolean;
-
-    /**
-     * Checks if the element is editable.
-     * @returns Whether the element is editable.
-     */
-    isEditable(): boolean;
-
-    /**
-     * Checks if the element is enabled.
-     * @returns Whether the element is enabled.
-     */
-    isEnabled(): boolean;
-
-    /**
-     * Checks if the element is hidden.
-     * @returns Whether the element is hidden.
-     */
-    isHidden(): boolean;
-
-    /**
-     * Checks if the element is visible.
-     * @returns Whether the element is visible.
-     */
-    isVisible(): boolean;
-
-    /**
-     * Returns the frame containing the given element.
-     * @returns The frame that contains the element handle.
-     */
-    ownerFrame(): Frame;
-
-    /**
-     * Focuses the element, and then uses `keyboard.down` and `keyboard.up` with the specified key.
-     * @param key A keyboard key name or a single character to press.
-     * @param options Keyboard press options.
-     */
-    press(key: string, options?: KeyboardPressOptions): void;
-
-    /**
-     * This method scrolls element into view, if needed, and then captures a
-     * screenshot of it.
-     * @param options Screenshot options.
-     * @returns An `ArrayBuffer` with the screenshot data.
-     */
-    screenshot(options?: ScreenshotOptions & TimeoutOptions): ArrayBuffer;
-
-    /**
-     * This method checks whether the element is actionable using provided options, and
-     * then tries to scroll it into view, unless it is completely visible.
-     * @param options Element handle options.
-     */
-    scrollIntoViewIfNeeded(options?: ElementHandleOptions): void;
-
-    /**
-     * Select one or more options of a `<select>` element which match the values.
-     * @param values Values of options to select.
-     * @param options Element handle options.
-     * @returns List of selected options.
-     */
-    selectOption(
-        values: string | ElementHandle | SelectOptionsObject | string[] | ElementHandle[] | SelectOptionsObject[],
-        options?: ElementHandleOptions,
-    ): string[];
-
-    /**
-     * Focuses the element and selects all its text content.
-     * @param options Element handle options.
-     */
-    selectText(options?: ElementHandleOptions): void;
-
-    /**
-     * Scrolls element into view if needed, and then uses `page.tapscreen` to tap in the center of the element
-     * or at the specified position.
-     * @param options Tap options.
-     */
-    tap(options?: MouseMoveOptions): void;
-
-    /**
-     * Returns the `node.textContent`.
-     * @returns The text content of the element.
-     */
-    textContent(): string;
-
-    /**
-     * Scrolls element into view, focuses element and types text.
-     * @param text Text to type into the element.
-     * @param options Typing options.
-     */
-    type(text: string, options?: KeyboardPressOptions): void;
-
-    /**
-     * Scrolls element into view, and if it's an input element of type
-     * checkbox that is already checked, clicks on it to mark it as unchecked.
-     * @param options Click options.
-     */
-    uncheck(options?: ElementClickOptions & StrictnessOptions): void;
-
-    /**
-     * Returns when the element satisfies the `state`.
-     * @param state Wait for element to satisfy this state.
-     * @param options Wait options.
-     */
-    waitForElementState(state: InputElementState, options?: TimeoutOptions): void;
-
-    /**
-     * Returns when the child element matching `selector` satisfies the `state`.
-     * @param selector A selector to query for.
-     * @param options Wait options.
-     */
-    waitForSelector(selector: string, options?: { state?: ElementState } & StrictnessOptions & TimeoutOptions): void;
-}