askui 0.4.0 → 0.6.0

package/dist/esm/execution/dsl.js

@@ -794,6 +794,120 @@ export class FluentFilters extends FluentBase {
 }
 // Relations
 export class FluentFiltersOrRelations extends FluentFilters {
+    /**
+     * Logic or operator
+     *
+     * **Examples:**
+     * ```text
+     * scene 1
+     * --------------  ---------------
+     * |  button    |  |  icon       |
+     * --------------  ---------------
+     *
+     * scene 2
+     * --------------  ---------------
+     * |  button    |  |  text       |
+     * --------------  ---------------
+     *
+     * ```
+     * In case, that your reference element can have multiple values, in the following example, the element right of the button can be either icon or text.
+     * You can use **the `or()` relation**, so your teststep is valid for both scenes
+     * ```typescript
+     * const button = await aui.get().button().rightOf().icon().or().text().exec();
+     * console.log(button);
+     * ```
+     * Returns the same button for both cases
+     * ```text
+     *  console output: [
+     *   DetectedElement {
+     *      name: 'BUTTON',
+     *      text: 'button',
+     *      colors: [ 'red', 'black', 'red' ],
+     *      bndbox: BoundingBox {
+     *         xmin: 900,
+     *         ymin: 910,
+     *         xmax: 920,
+     *         ymax: 930
+     *      }
+     *   }
+     *  ]
+     * ```
+     *
+     * @return {FluentFilters}
+     */
+    or() {
+        this._textStr = 'or';
+        return new FluentFilters(this);
+    }
+    /**
+     * Logic and operator
+     *
+     * **Examples:**
+     * ```text
+     * example scene:
+     *  --------------------------   --------------------------
+     *  |  icon user colored black | |  icon  user colored red |
+     *  --------------------------   --------------------------
+     * ```
+     * ```typescript
+     * const icons = await aui.get().icon().withText('user').exec();
+     * console.log(icons);
+     * ```
+     * Using only the filter withText, the get command will return both icons because they share the same text
+     * ```text
+     * console output: [
+     *   DetectedElement {
+     *      name: 'ICON',
+     *      text: 'user',
+     *      colors: [ 'black', 'black', 'black' ],
+     *      bndbox: BoundingBox {
+     *         xmin: 1000,
+     *         ymin: 1010,
+     *         xmax: 1020,
+     *         ymax: 1030
+     *      }
+     *   },
+     *   DetectedElement {
+     *      name: 'ICON',
+     *      text: 'user',
+     *      colors: [ 'red', 'red', 'red' ],
+     *      bndbox: BoundingBox {
+     *         xmin: 900,
+     *         ymin: 910,
+     *         xmax: 920,
+     *         ymax: 930
+     *      }
+     *   }
+     *  ]
+     * ```
+     * You can combine filters with **the `and()` relation** and specify exactly which icon you want
+     * ```typescript
+     * const icons = await aui.get().icon().withText('user').and().colored('red').exec()
+     * console.log(icons)
+     * ```
+     * The get command returns only the red icon although both icons have the same text
+     * ```text
+     *  console output: [
+     *   DetectedElement {
+     *      name: 'ICON',
+     *      text: 'user',
+     *      colors: [ 'red', 'red', 'red' ],
+     *      bndbox: BoundingBox {
+     *         xmin: 900,
+     *         ymin: 910,
+     *         xmax: 920,
+     *         ymax: 930
+     *      }
+     *   }
+     *  ]
+     * ```
+     *
+     * @return {FluentFilters}
+     */
+    and() {
+        this._textStr = 'and';
+        return new FluentFilters(this);
+    }
     /**
      * Filters for an element inside another element.
      *
@@ -1704,6 +1818,120 @@ export class FluentFiltersCondition extends FluentBase {
 }
 // Relations
 export class FluentFiltersOrRelationsCondition extends FluentFiltersCondition {
+    /**
+     * Logic or operator
+     *
+     * **Examples:**
+     * ```text
+     * scene 1
+     * --------------  ---------------
+     * |  button    |  |  icon       |
+     * --------------  ---------------
+     *
+     * scene 2
+     * --------------  ---------------
+     * |  button    |  |  text       |
+     * --------------  ---------------
+     *
+     * ```
+     * In case, that your reference element can have multiple values, in the following example, the element right of the button can be either icon or text.
+     * You can use **the `or()` relation**, so your teststep is valid for both scenes
+     * ```typescript
+     * const button = await aui.get().button().rightOf().icon().or().text().exec();
+     * console.log(button);
+     * ```
+     * Returns the same button for both cases
+     * ```text
+     *  console output: [
+     *   DetectedElement {
+     *      name: 'BUTTON',
+     *      text: 'button',
+     *      colors: [ 'red', 'black', 'red' ],
+     *      bndbox: BoundingBox {
+     *         xmin: 900,
+     *         ymin: 910,
+     *         xmax: 920,
+     *         ymax: 930
+     *      }
+     *   }
+     *  ]
+     * ```
+     *
+     * @return {FluentFiltersCondition}
+     */
+    or() {
+        this._textStr = 'or';
+        return new FluentFiltersCondition(this);
+    }
+    /**
+     * Logic and operator
+     *
+     * **Examples:**
+     * ```text
+     * example scene:
+     *  --------------------------   --------------------------
+     *  |  icon user colored black | |  icon  user colored red |
+     *  --------------------------   --------------------------
+     * ```
+     * ```typescript
+     * const icons = await aui.get().icon().withText('user').exec();
+     * console.log(icons);
+     * ```
+     * Using only the filter withText, the get command will return both icons because they share the same text
+     * ```text
+     * console output: [
+     *   DetectedElement {
+     *      name: 'ICON',
+     *      text: 'user',
+     *      colors: [ 'black', 'black', 'black' ],
+     *      bndbox: BoundingBox {
+     *         xmin: 1000,
+     *         ymin: 1010,
+     *         xmax: 1020,
+     *         ymax: 1030
+     *      }
+     *   },
+     *   DetectedElement {
+     *      name: 'ICON',
+     *      text: 'user',
+     *      colors: [ 'red', 'red', 'red' ],
+     *      bndbox: BoundingBox {
+     *         xmin: 900,
+     *         ymin: 910,
+     *         xmax: 920,
+     *         ymax: 930
+     *      }
+     *   }
+     *  ]
+     * ```
+     * You can combine filters with **the `and()` relation** and specify exactly which icon you want
+     * ```typescript
+     * const icons = await aui.get().icon().withText('user').and().colored('red').exec()
+     * console.log(icons)
+     * ```
+     * The get command returns only the red icon although both icons have the same text
+     * ```text
+     *  console output: [
+     *   DetectedElement {
+     *      name: 'ICON',
+     *      text: 'user',
+     *      colors: [ 'red', 'red', 'red' ],
+     *      bndbox: BoundingBox {
+     *         xmin: 900,
+     *         ymin: 910,
+     *         xmax: 920,
+     *         ymax: 930
+     *      }
+     *   }
+     *  ]
+     * ```
+     *
+     * @return {FluentFiltersCondition}
+     */
+    and() {
+        this._textStr = 'and';
+        return new FluentFiltersCondition(this);
+    }
     /**
      * Filters for an element inside another element.
      *
@@ -2922,6 +3150,120 @@ export class FluentFiltersGetter extends FluentBase {
 }
 // Relations
 export class FluentFiltersOrRelationsGetter extends FluentFiltersGetter {
+    /**
+     * Logic or operator
+     *
+     * **Examples:**
+     * ```text
+     * scene 1
+     * --------------  ---------------
+     * |  button    |  |  icon       |
+     * --------------  ---------------
+     *
+     * scene 2
+     * --------------  ---------------
+     * |  button    |  |  text       |
+     * --------------  ---------------
+     *
+     * ```
+     * In case, that your reference element can have multiple values, in the following example, the element right of the button can be either icon or text.
+     * You can use **the `or()` relation**, so your teststep is valid for both scenes
+     * ```typescript
+     * const button = await aui.get().button().rightOf().icon().or().text().exec();
+     * console.log(button);
+     * ```
+     * Returns the same button for both cases
+     * ```text
+     *  console output: [
+     *   DetectedElement {
+     *      name: 'BUTTON',
+     *      text: 'button',
+     *      colors: [ 'red', 'black', 'red' ],
+     *      bndbox: BoundingBox {
+     *         xmin: 900,
+     *         ymin: 910,
+     *         xmax: 920,
+     *         ymax: 930
+     *      }
+     *   }
+     *  ]
+     * ```
+     *
+     * @return {FluentFiltersGetter}
+     */
+    or() {
+        this._textStr = 'or';
+        return new FluentFiltersGetter(this);
+    }
+    /**
+     * Logic and operator
+     *
+     * **Examples:**
+     * ```text
+     * example scene:
+     *  --------------------------   --------------------------
+     *  |  icon user colored black | |  icon  user colored red |
+     *  --------------------------   --------------------------
+     * ```
+     * ```typescript
+     * const icons = await aui.get().icon().withText('user').exec();
+     * console.log(icons);
+     * ```
+     * Using only the filter withText, the get command will return both icons because they share the same text
+     * ```text
+     * console output: [
+     *   DetectedElement {
+     *      name: 'ICON',
+     *      text: 'user',
+     *      colors: [ 'black', 'black', 'black' ],
+     *      bndbox: BoundingBox {
+     *         xmin: 1000,
+     *         ymin: 1010,
+     *         xmax: 1020,
+     *         ymax: 1030
+     *      }
+     *   },
+     *   DetectedElement {
+     *      name: 'ICON',
+     *      text: 'user',
+     *      colors: [ 'red', 'red', 'red' ],
+     *      bndbox: BoundingBox {
+     *         xmin: 900,
+     *         ymin: 910,
+     *         xmax: 920,
+     *         ymax: 930
+     *      }
+     *   }
+     *  ]
+     * ```
+     * You can combine filters with **the `and()` relation** and specify exactly which icon you want
+     * ```typescript
+     * const icons = await aui.get().icon().withText('user').and().colored('red').exec()
+     * console.log(icons)
+     * ```
+     * The get command returns only the red icon although both icons have the same text
+     * ```text
+     *  console output: [
+     *   DetectedElement {
+     *      name: 'ICON',
+     *      text: 'user',
+     *      colors: [ 'red', 'red', 'red' ],
+     *      bndbox: BoundingBox {
+     *         xmin: 900,
+     *         ymin: 910,
+     *         xmax: 920,
+     *         ymax: 930
+     *      }
+     *   }
+     *  ]
+     * ```
+     *
+     * @return {FluentFiltersGetter}
+     */
+    and() {
+        this._textStr = 'and';
+        return new FluentFiltersGetter(this);
+    }
     /**
      * Filters for an element inside another element.
      *
@@ -3102,7 +3444,32 @@ export class FluentFiltersOrRelationsGetter extends FluentFiltersGetter {
 // Commands
 export class Getter extends FluentCommand {
     /**
-     * Returns the filtered element
+     * Returns an array with all filtered elements.
+     * A detected element has the following properties:
+     * - `name` of the element
+     * - `text` content of element
+     * - `colors` of element
+     * - `bndbox`: location of element described with coordinates of a bounding box
+     * **Examples:**
+     * ```typescript
+     * const text = await aui.get().text().withText('Sign').exec();
+     * console.log(text);
+     * ```
+     * ```text
+     *  console output: [
+     *   DetectedElement {
+     *      name: 'TEXT',
+     *      text: 'Sign In',
+     *      colors: [ 'black', 'gray', 'gray' ],
+     *      bndbox: BoundingBox {
+     *         xmin: 1128.2720982142857,
+     *         ymin: 160.21332310267857,
+     *         xmax: 1178.8204241071428,
+     *         ymax: 180.83512834821428
+     *      }
+     *  }
+     *  ]
+     * ```
      *
      * @return {FluentFiltersGetter}
      */
@@ -3111,7 +3478,43 @@ export class Getter extends FluentCommand {
         return new FluentFiltersGetter(this);
     }
     /**
-     * Returns all detected elements
+     * Returns an array with all detected elements.
+     * A detected element has the following properties:
+     * - `name` of the element
+     * - `text` content of element
+     * - `colors` of element
+     * - `bndbox`: location of element described with coordinates of a bounding box
+     * **Examples:**
+     * ```typescript
+     * const detectedElements = await aui.getAll().exec();
+     * console.log(detectedElements);
+     * ```
+     * ```text
+     *  console output: [
+     *   DetectedElement {
+     *      name: 'TEXT',
+     *      text: 'Sign In',
+     *      colors: [ 'black', 'gray', 'gray' ],
+     *      bndbox: BoundingBox {
+     *         xmin: 1128.2720982142857,
+     *         ymin: 160.21332310267857,
+     *         xmax: 1178.8204241071428,
+     *         ymax: 180.83512834821428
+     *      },
+     *   DetectedElement {
+     *      name: 'ICON',
+     *      text: 'search',
+     *      colors: [ 'black', 'red', 'gray' ],
+     *      bndbox: BoundingBox {
+     *         xmin: 250.8204241071428,
+     *         ymin: 300.21332310267857,
+     *         xmax: 450.6304241071428,
+     *         ymax: 950.47812834821428
+     *      },
+     *      ... 381 more items
+     *  }
+     *  ]
+     * ```
      *
      * @return {ExecGetter}
      */

package/dist/esm/execution/inference-client.d.ts

@@ -6,10 +6,11 @@ import { DetectedElement } from '../core/model/annotation-result/detected-elemen
 export declare class InferenceClient {
     baseUrl: string;
     httpClient: HttpClientGot;
+    resize?: number | undefined;
     readonly workspaceId?: string | undefined;
     apiVersion: string;
     url: string;
-    constructor(baseUrl: string, httpClient: HttpClientGot, workspaceId?: string | undefined, apiVersion?: string);
+    constructor(baseUrl: string, httpClient: HttpClientGot, resize?: number | undefined, workspaceId?: string | undefined, apiVersion?: string);
     isImageRequired(instruction: string): Promise<boolean>;
     private resizeIfNeeded;
     inference(customElements?: CustomElement[], image?: string, instruction?: string): Promise<ControlCommand | Annotation>;

package/dist/esm/execution/inference-client.js

@@ -12,14 +12,20 @@ import { ControlCommand, InferenceResponse } from '../core/ui-control-commands';
 import { Annotation } from '../core/annotation/annotation';
 import { resizeBase64ImageWithSameRatio } from '../utils/transformations';
 import { InferenceResponseError } from './inference-response-error';
+import { ConfigurationError } from './config-error';
 export class InferenceClient {
-    constructor(baseUrl, httpClient, workspaceId, apiVersion = 'v3') {
+    constructor(baseUrl, httpClient, resize, workspaceId, apiVersion = 'v3') {
         this.baseUrl = baseUrl;
         this.httpClient = httpClient;
+        this.resize = resize;
         this.workspaceId = workspaceId;
         this.apiVersion = apiVersion;
         const versionedBaseUrl = urljoin(this.baseUrl, 'api', this.apiVersion);
         this.url = workspaceId ? urljoin(versionedBaseUrl, 'workspaces', workspaceId) : versionedBaseUrl;
+        if (this.resize !== undefined && this.resize <= 0) {
+            throw new ConfigurationError(`Resize must be a positive number. The current resize value "${this.resize}" is not valid.`);
+        }
+        this.resize = this.resize ? Math.ceil(this.resize) : this.resize;
     }
     isImageRequired(instruction) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -34,10 +40,10 @@ export class InferenceClient {
     // eslint-disable-next-line class-methods-use-this
     resizeIfNeeded(customElements, image) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!(image) || customElements.length > 0) {
+            if (!(image) || customElements.length > 0 || this.resize === undefined) {
                 return { base64Image: image, resizeRatio: 1 };
             }
-            return resizeBase64ImageWithSameRatio(image);
+            return resizeBase64ImageWithSameRatio(image, this.resize);
         });
     }
     inference(customElements = [], image, instruction) {

package/dist/esm/execution/ui-control-client.js

@@ -20,6 +20,7 @@ import { AnnotationLevel } from './annotation-level';
 import { UiControlClientError } from './ui-control-client-error';
 import { envCredentials } from './read-environment-credentials';
 import { Analytics } from '../utils/analytics';
+import { buildProxyAgentArgsFromEnvironment } from '../utils/proxy/proxy-builder';
 const getClientArgsWithDefaults = (clientArgs = {}) => (Object.assign({ uiControllerUrl: 'http://127.0.0.1:6769', inferenceServerUrl: 'https://inference.askui.com', annotationLevel: AnnotationLevel.DISABLED }, clientArgs));
 export class UiControlClient extends ApiCommands {
     constructor(httpClient, clientArgs, workspaceId) {
@@ -36,7 +37,8 @@ export class UiControlClient extends ApiCommands {
             const analyticsCookies = yield analytics.getAnalyticsCookies();
             const cas = getClientArgsWithDefaults(clientArgs);
             const credentialArgs = cas.credentials || envCredentials();
-            const httpClient = new HttpClientGot(credentialArgs === null || credentialArgs === void 0 ? void 0 : credentialArgs.token, analyticsHeaders, analyticsCookies);
+            const proxyAgentArgs = cas.proxyAgents || (yield buildProxyAgentArgsFromEnvironment());
+            const httpClient = new HttpClientGot(credentialArgs === null || credentialArgs === void 0 ? void 0 : credentialArgs.token, analyticsHeaders, analyticsCookies, proxyAgentArgs);
             return new UiControlClient(httpClient, cas, credentialArgs === null || credentialArgs === void 0 ? void 0 : credentialArgs.workspaceId);
         });
     }
@@ -47,7 +49,7 @@ export class UiControlClient extends ApiCommands {
         return this._uiControllerClient;
     }
     get inferenceClient() {
-        return new InferenceClient(this.clientArgs.inferenceServerUrl, this.httpClient, this.workspaceId);
+        return new InferenceClient(this.clientArgs.inferenceServerUrl, this.httpClient, this.clientArgs.resize, this.workspaceId);
     }
     get executionRuntime() {
         return new ExecutionRuntime(this.uiControllerClient, this.inferenceClient);

package/dist/esm/execution/ui-controller-client-interface.d.ts

@@ -1,10 +1,19 @@
 import { AnnotationLevel } from './annotation-level';
 import { CredentialArgs } from './credentials-args';
+import { ProxyAgentArgs } from '../shared/proxy-agent-args';
 /**
  * Configuration options for the askui UI Control Client
  *
  * @param {string} uiControllerUrl - Default: http://127.0.0.1:6769
  * The adress of the askui UI Controller server.
+ * @param {(number | undefined)} resize - Default: undefined
+ * The resizing will be skipped if it's undefined.
+ * The side length of the target image to resize to in px.
+ * Your screenshot image will be resized with the original aspect ratio,
+ *  and the lengths image side will be equal to this number.
+ * This can be used to reduce the inference time by reducing
+ *  the request size in case of a bad internet connection.
+ * But it can cause a decrease in the prediction quality.
  * @param {string} inferenceClientUrl - Default: https://inference.askui.com`
  * Address of the askui Inference server.
  * @param {AnnotationLevel} annotationLevel - Default: AnnotationLevel.DISABLED
@@ -13,12 +22,16 @@ import { CredentialArgs } from './credentials-args';
  * You have three options: `DISABLED`, `ON_FAILURE`, `ALL`.
  * @param {CredentialArgs} credentials - We need to provide credentials for
  * the authentication of the askui Inference Server.
+ * You have three options: `DISABLED`, `ON_FAILURE`, `ALL`.
+ * @param {ProxyAgentArgs} proxyAgents - To configure the proxy agents for http(s) requests.
  */
 export interface ClientArgs {
     readonly uiControllerUrl?: string;
     readonly inferenceServerUrl?: string;
     readonly annotationLevel?: AnnotationLevel;
     readonly credentials?: CredentialArgs;
+    readonly proxyAgents?: ProxyAgentArgs;
+    readonly resize?: number;
 }
 export interface ClientArgsWithDefaults extends ClientArgs {
     readonly uiControllerUrl: string;

package/dist/esm/lib/copy-example-project.js

@@ -1,15 +1,46 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 import { Command } from 'commander';
 import path from 'path';
 import fs from 'fs-extra';
 import { getPathToNodeModulesRoot } from '../utils/path';
+import { logger } from './logger';
 const createProgram = () => {
     const program = new Command('askui');
     program.usage('<command> [options]');
     return program;
 };
-function copyExampleProject() {
-    const exampleProjectPath = path.join('example_projects_templates', 'typescript_jest');
-    fs.copySync(path.join(getPathToNodeModulesRoot(), exampleProjectPath), '.');
+function replaceStringInFile(filePath, replace, replacement) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const data = yield fs.readFile(filePath, 'utf8');
+            const result = data.replace(replace, replacement);
+            yield fs.writeFile(filePath, result, 'utf8');
+        }
+        catch (error) {
+            logger.error(`Could not replace '${replace}' with '${replacement}' in file '${path}'`);
+            logger.error(error.message);
+        }
+    });
+}
+function copyExampleProject(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const exampleProjectPath = path.join('example_projects_templates', 'typescript_jest');
+        fs.copySync(path.join(getPathToNodeModulesRoot(), exampleProjectPath), '.');
+        if (options['workspaceId']) {
+            yield replaceStringInFile('./test/helper/jest.setup.ts', '<your workspace id>', options['workspaceId']);
+        }
+        if (options['accessToken']) {
+            yield replaceStringInFile('./test/helper/jest.setup.ts', '<your access token>', options['accessToken']);
+        }
+    });
 }
 export function init(argv) {
     const args = argv || process.argv;
@@ -17,6 +48,11 @@ export function init(argv) {
     program
         .command('init')
         .description('creates a typescript example project')
-        .action(() => { copyExampleProject(); });
+        .option('-w, --workspace-id <value>', 'a workspace id')
+        .option('-a, --access-token <value>', 'an access token for the workspace with the id')
+        .usage('[-w workspace_id] [-a access_token]')
+        .action((opts) => __awaiter(this, void 0, void 0, function* () {
+        yield copyExampleProject(opts);
+    }));
     return program.parse(args);
 }

package/dist/esm/lib/download-binaries.d.ts

@@ -1,3 +1,6 @@
+/// <reference types="node" />
+import http from 'http';
+import https from 'https';
 declare enum SupportedPlatform {
     LINUX = "linux",
     DARWIN = "darwin",
@@ -5,5 +8,8 @@ declare enum SupportedPlatform {
 }
 export declare function platform(): SupportedPlatform;
 export declare function getBinaryPath(version: string): string;
-export declare function downloadServerBinaries(binaryVersion: string): Promise<void>;
+export declare function downloadServerBinaries(binaryVersion: string, proxyAgent?: {
+    http: http.Agent;
+    https: https.Agent;
+}): Promise<void>;
 export {};

package/dist/esm/lib/download-binaries.js

@@ -36,7 +36,7 @@ function getBinaryDownloadUrl(binaryVersion) {
     const arch = os.arch();
     return `${baseUrl}/${platform()}/${arch}/${binarySubPathsByPlatform[platform()][1]}`;
 }
-export function downloadServerBinaries(binaryVersion) {
+export function downloadServerBinaries(binaryVersion, proxyAgent) {
     return new Promise((resolve, reject) => {
         const url = getBinaryDownloadUrl(binaryVersion);
         const binaryOutputPath = getBinaryPath(binaryVersion);
@@ -45,7 +45,7 @@ export function downloadServerBinaries(binaryVersion) {
         if (!(fs.existsSync(binaryFolder))) {
             fs.mkdirSync(binaryFolder, { recursive: true });
         }
-        const downloadStream = got.stream(url);
+        const downloadStream = got.stream(url, proxyAgent ? { agent: proxyAgent } : {});
         const fileWriterStream = fs.createWriteStream(binaryOutputPath);
         downloadStream.on('error', () => {
             reject();

package/dist/esm/lib/ui-controller-args.d.ts

@@ -1,3 +1,4 @@
+import { ProxyAgentArgs } from '../shared/proxy-agent-args';
 import { LogLevels } from '../shared/log-levels';
 /**
  * Configuration options for the askui UI Controller
@@ -5,6 +6,7 @@ import { LogLevels } from '../shared/log-levels';
  * @param {number} display - Default: `0`
  * You can choose on which display you want to excecute all tests.
  * 0 is your main monitor.
+ *
  * If you want to use your second monitor you can change
  * the value to `1` (`2` for your third monitor etc.).
  * @param {string} binaryVersion - Default: `'latest'`
@@ -26,6 +28,7 @@ import { LogLevels } from '../shared/log-levels';
  * @param {string} logFilePath - Default: `'<temp-dir>/askui/askui-server.log'`
  * It is possible to specify a path for your log files.
  * Per default we create the askui-server.log file and askui folder in your temp folder.
+ * @param {ProxyAgentArgs} proxyAgents - To configure the proxy agents for our http(s) requests.
  */
 export interface UiControllerArgs {
     readonly display?: number;
@@ -37,6 +40,7 @@ export interface UiControllerArgs {
     readonly overWriteBinary?: boolean;
     readonly logLevel?: LogLevels;
     readonly logFilePath?: string;
+    readonly proxyAgents?: ProxyAgentArgs;
 }
 export interface UiControllerArgsWithDefaults extends UiControllerArgs {
     readonly display: number;