askui 0.1.5 → 0.2.1

package/dist/esm/execution/execution-runtime.d.ts

@@ -1,13 +1,14 @@
 import { TestStep } from '../core/model/test-case-dto';
-import { ControlYourUiClient } from './control-your-ui-client';
-import { ControlYourUiApi } from './control-your-ui-api';
+import { UiControllerClient } from './ui-controller-client';
+import { InferenceClient } from './inference-client';
 import { Annotation } from '../core/annotation/annotation';
 import { CustomElementJson } from '../core/model/test-case-dto/custom-element-json';
 export declare class ExecutionRuntime {
-    private client;
-    private api;
-    constructor(client: ControlYourUiClient, api: ControlYourUiApi);
+    private uiControllerClient;
+    private inferenceClient;
+    constructor(uiControllerClient: UiControllerClient, inferenceClient: InferenceClient);
     executeTestStep(step: TestStep): Promise<void>;
+    private requestControl;
     /**
      * @param {TestStep} step - Test step used for predicting command.
      */
@@ -20,6 +21,7 @@ export declare class ExecutionRuntime {
      * --> retry with linear back-off
      */
     private predictCommandWithRetry;
+    private getImageIfRequired;
     private predictCommand;
     annotateInteractively(): Promise<void>;
     takeScreenshotIfImageisNotProvided(imagePath?: string): Promise<string>;

package/dist/esm/execution/execution-runtime.js

@@ -12,12 +12,12 @@ import { CustomElement } from '../core/model/test-case-dto';
 import { RepeatError } from './repeat-error';
 import { delay } from './misc';
 import { ControlCommandError } from './control-command-error';
-import { toBase64Image } from '../utils/transformations';
 import { logger } from '../lib/logger';
+import { Base64Image } from '../utils/base_64_image/base-64-image';
 export class ExecutionRuntime {
-    constructor(client, api) {
-        this.client = client;
-        this.api = api;
+    constructor(uiControllerClient, inferenceClient) {
+        this.uiControllerClient = uiControllerClient;
+        this.inferenceClient = inferenceClient;
         this.EXEC_REPETITION_COUNT = 25;
         this.PREDICT_COMMAND_RETRY_COUNT = 2;
     }
@@ -27,6 +27,11 @@ export class ExecutionRuntime {
             yield this.executeCommand(step);
         });
     }
+    requestControl(controlCommand) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.uiControllerClient.requestControl(controlCommand);
+        });
+    }
     /**
      * @param {TestStep} step - Test step used for predicting command.
      */
@@ -35,15 +40,13 @@ export class ExecutionRuntime {
         return __awaiter(this, void 0, void 0, function* () {
             const controlCommand = yield this.predictCommandWithRetry(step);
             if (controlCommand.code === ControlCommandCode.OK) {
-                yield this.client.requestControl(controlCommand);
-            }
-            else if (controlCommand.tryToRepeat) {
-                yield this.client.requestControl(controlCommand);
-                this.executeCommandRepeatedly(step);
+                return this.requestControl(controlCommand);
             }
-            else {
-                throw new ControlCommandError(((_a = controlCommand.actions[0]) === null || _a === void 0 ? void 0 : _a.text) || '');
+            if (controlCommand.tryToRepeat) {
+                yield this.requestControl(controlCommand);
+                return this.executeCommandRepeatedly(step);
             }
+            throw new ControlCommandError(((_a = controlCommand.actions[0]) === null || _a === void 0 ? void 0 : _a.text) || '');
         });
     }
     executeCommandRepeatedly(step) {
@@ -60,8 +63,8 @@ export class ExecutionRuntime {
                 if (controlCommand.code === ControlCommandCode.OK) {
                     break;
                 }
-                else if (controlCommand.tryToRepeat) {
-                    yield this.client.requestControl(controlCommand);
+                if (controlCommand.tryToRepeat) {
+                    yield this.requestControl(controlCommand);
                 }
                 else {
                     throw new ControlCommandError(((_a = controlCommand.actions[0]) === null || _a === void 0 ? void 0 : _a.text) || '');
@@ -91,31 +94,40 @@ export class ExecutionRuntime {
             return command;
         });
     }
+    getImageIfRequired(instruction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isImageRequired = yield this.inferenceClient.isImageRequired(instruction);
+            if (!isImageRequired) {
+                return undefined;
+            }
+            const screenshotResponse = yield this.uiControllerClient.requestScreenshot();
+            return screenshotResponse.data.image;
+        });
+    }
     predictCommand(step) {
         return __awaiter(this, void 0, void 0, function* () {
-            const isImageRequired = yield this.api.isImageRequired(step.instruction);
-            let image;
-            if (isImageRequired) {
-                const screenshotResponse = yield this.client.requestScreenshot();
-                image = screenshotResponse.data.image;
+            const image = yield this.getImageIfRequired(step.instruction);
+            const controlCommand = yield this.inferenceClient.predictControlCommand(step.instruction, step.customElements, image);
+            if (step.secretText !== undefined) {
+                controlCommand.setTextToBeTyped(step.secretText);
             }
-            return this.api.predictControlCommand(step.instruction, step.customElements, image);
+            return controlCommand;
         });
     }
     annotateInteractively() {
         return __awaiter(this, void 0, void 0, function* () {
             const annotationResponse = yield this.annotateImage();
-            yield this.client.annotateInteractively(annotationResponse.objects, annotationResponse.image);
+            yield this.uiControllerClient.annotateInteractively(annotationResponse.objects, annotationResponse.image);
         });
     }
     takeScreenshotIfImageisNotProvided(imagePath) {
         return __awaiter(this, void 0, void 0, function* () {
             let base64Image = '';
             if (imagePath !== undefined) {
-                base64Image = yield toBase64Image(imagePath);
+                base64Image = (yield Base64Image.fromPath(imagePath)).toString();
             }
             if (imagePath === undefined) {
-                const screenshotResponse = yield this.client.requestScreenshot();
+                const screenshotResponse = yield this.uiControllerClient.requestScreenshot();
                 base64Image = screenshotResponse.data.image;
             }
             return base64Image;
@@ -128,7 +140,7 @@ export class ExecutionRuntime {
             if (customElementJson !== undefined) {
                 customElements = yield CustomElement.fromJsonListWithImagePathOrImage(customElementJson);
             }
-            return this.api.predictImageAnnotation(base64Image, customElements);
+            return this.inferenceClient.predictImageAnnotation(base64Image, customElements);
         });
     }
 }

package/dist/esm/execution/index.d.ts

@@ -1 +1,2 @@
-export { AskuiClient } from './client';
+export { AnnotationLevel } from './annotation-level';
+export { UiControlClient } from './ui-control-client';

package/dist/esm/execution/index.js

@@ -1 +1,2 @@
-export { AskuiClient } from './client';
+export { AnnotationLevel } from './annotation-level';
+export { UiControlClient } from './ui-control-client';

package/dist/esm/execution/{control-your-ui-api.d.ts → inference-client.d.ts}

@@ -2,12 +2,12 @@ import { HttpClientGot } from '../utils/http/http-client-got';
 import { ControlCommand } from '../core/ui-control-commands';
 import { CustomElement } from '../core/model/test-case-dto';
 import { Annotation } from '../core/annotation/annotation';
-export declare class ControlYourUiApi {
-    apiEndpointUrl: string;
+export declare class InferenceClient {
+    url: string;
     httpClient: HttpClientGot;
-    constructor(apiEndpointUrl: string, httpClient: HttpClientGot);
+    constructor(url: string, httpClient: HttpClientGot);
     isImageRequired(instruction: string): Promise<boolean>;
     private resizeIfNeeded;
-    predictControlCommand(instruction: string, customElements: CustomElement[], image?: string): Promise<ControlCommand>;
+    predictControlCommand(instruction: string, customElements?: CustomElement[], image?: string): Promise<ControlCommand>;
     predictImageAnnotation(image: string, customElements?: CustomElement[]): Promise<Annotation>;
 }

package/dist/esm/execution/{control-your-ui-api.js → inference-client.js}

@@ -11,14 +11,14 @@ import urljoin from 'url-join';
 import { ControlCommand } from '../core/ui-control-commands';
 import { Annotation } from '../core/annotation/annotation';
 import { resizeBase64ImageWithSameRatio } from '../utils/transformations';
-export class ControlYourUiApi {
-    constructor(apiEndpointUrl, httpClient) {
-        this.apiEndpointUrl = apiEndpointUrl;
+export class InferenceClient {
+    constructor(url, httpClient) {
+        this.url = url;
         this.httpClient = httpClient;
     }
     isImageRequired(instruction) {
         return __awaiter(this, void 0, void 0, function* () {
-            const url = urljoin(this.apiEndpointUrl, 'instruction', 'is-image-required');
+            const url = urljoin(this.url, 'instruction', 'is-image-required');
             const httpBody = {
                 instruction,
             };
@@ -35,7 +35,7 @@ export class ControlYourUiApi {
             return resizeBase64ImageWithSameRatio(image);
         });
     }
-    predictControlCommand(instruction, customElements, image) {
+    predictControlCommand(instruction, customElements = [], image) {
         return __awaiter(this, void 0, void 0, function* () {
             const resizedImage = yield this.resizeIfNeeded(customElements, image);
             const httpBody = {
@@ -43,7 +43,7 @@ export class ControlYourUiApi {
                 instruction,
                 customElements,
             };
-            const url = urljoin(this.apiEndpointUrl, 'api', 'v1', 'predict-command');
+            const url = urljoin(this.url, 'api', 'v1', 'predict-command');
             const httpResponse = yield this.httpClient.post(url, httpBody);
             return ControlCommand.fromJson(httpResponse, resizedImage.resizeRatio);
         });
@@ -55,7 +55,7 @@ export class ControlYourUiApi {
                 image: resizedImage.base64Image,
                 customElements,
             };
-            const url = urljoin(this.apiEndpointUrl, 'annotate', '?format=json');
+            const url = urljoin(this.url, 'annotate', '?format=json');
             const httpResponse = yield this.httpClient.post(url, httpBody);
             return Annotation.fromJson(Object.assign(Object.assign({}, httpResponse), { image }), resizedImage.resizeRatio);
         });

package/dist/esm/execution/ui-control-client-error.d.ts

@@ -0,0 +1,2 @@
+export declare class UiControlClientError extends Error {
+}

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

@@ -0,0 +1,2 @@
+export class UiControlClientError extends Error {
+}

package/dist/esm/execution/ui-control-client.d.ts

@@ -0,0 +1,79 @@
+import { CustomElementJson } from '../core/model/test-case-dto';
+import { Exec, Executable, FluentCommand, FluentFilters } from './dsl';
+import { UiControllerClientConnectionState } from './ui-controller-client-connection-state';
+import { Annotation } from '../core/annotation/annotation';
+import { AnnotationRequest } from '../core/model/annotation-result/annotation-interface';
+import { ClientArgs } from './ui-controller-client-interface';
+export declare class UiControlClient extends FluentCommand {
+    private httpClient;
+    private clientArgs;
+    private _uiControllerClient?;
+    private constructor();
+    static build(clientArgs?: ClientArgs): Promise<UiControlClient>;
+    private get uiControllerClient();
+    private get inferenceClient();
+    private get executionRuntime();
+    private annotateByDefault;
+    connect(): Promise<UiControllerClientConnectionState>;
+    annotate(annotationRequest?: AnnotationRequest): Promise<Annotation>;
+    annotateInteractively(): Promise<void>;
+    exec(instruction: string, customElementJson?: CustomElementJson[]): Promise<void>;
+    private secretText;
+    /**
+     * Types a text inside the filtered element.
+     *
+     * By default, the `text` is included in the logs and sent over to the askui Inference server to
+     * predict in which context the typing has to occur. You can exclude the `text` from the logs
+     * and the request to the askui Inference server setting `options.isSecret` to `true`.
+     * This should not change the quality of the prediction of the askui Inference server. In this
+     * case, `options.secretMask` is included in logs and sent over instead of the `text`.
+     *
+     * @param {string} text - A text to type.
+     * @param {Object} [options]
+     * @param {boolean} [options.isSecret = false] - If set to `true`, `text` is neither included in
+     *   logs of askui nor sent over to askui Inference for prediction.
+     * @param {string} [options.secretMask = '****'] - If `options.isSecret` is set to `true`, this
+     *   is included in logs and sent over to askui Inference for prediction instead of the `text`.
+     *
+     * @return {FluentFilters}
+     */
+    typeIn(text: string, { isSecret, secretMask }?: {
+        isSecret?: boolean | undefined;
+        secretMask?: string | undefined;
+    }): FluentFilters;
+    /**
+     * Types a text at the current position.
+     *
+     * By default, the `text` is included in the logs and sent over to the askui Inference server to
+     * predict in which context the typing has to occur. You can exclude the `text` from the logs
+     * and the request to the askui Inference server setting `options.isSecret` to `true`.
+     * This should not change the quality of the prediction of the askui Inference server. In this
+     * case, `options.secretMask` is included in logs and sent over instead of the `text`.
+     *
+     * @param {string} text - A text to type.
+     * @param {Object} options
+     * @param {boolean} [options.isSecret = false] - If set to `true`, `text` is neither included in
+     *   logs of askui nor sent over to askui Inference for prediction.
+     * @param {string} [options.secretMask = '****'] - If `options.isSecret` is set to `true`, this
+     *   is included in logs and sent over to askui Inference for prediction instead of the `text`.
+     *
+     * @return {Exec}
+     */
+    type(text: string, { isSecret, secretMask }?: {
+        isSecret?: boolean | undefined;
+        secretMask?: string | undefined;
+    }): Exec;
+    /**
+     * Waits for `<delayInMs>` ms, e.g., 1000 ms. The exact delay may be a little longer
+     * than `<delayInMs>` but never shorter than that.
+     *
+     * @param {number} delayInMs - The delay in ms to wait for.
+     *
+     * @return {Executable}
+     */
+    waitFor(delayInMs: number): Executable;
+    /**
+    * closes the connection to the controlui-server`.
+    */
+    close(): void;
+}

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

@@ -0,0 +1,181 @@
+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 { CustomElement } from '../core/model/test-case-dto';
+import { FluentCommand, } from './dsl';
+import { HttpClientGot } from '../utils/http/http-client-got';
+import { UiControllerClient } from './ui-controller-client';
+import { ExecutionRuntime } from './execution-runtime';
+import { InferenceClient } from './inference-client';
+import { AnnotationWriter } from '../core/annotation/annotation-writer';
+import { logger } from '../lib/logger';
+import { TestStepState } from '../core/model/test-case-result-dto';
+import { AnnotationLevel } from './annotation-level';
+import { UiControlClientError } from './ui-control-client-error';
+import { envCredentials } from './read-environment-credentials';
+import { Analytics } from '../utils/analytics';
+const getClientArgsWithDefaults = (clientArgs = {}) => (Object.assign({ uiControllerUrl: 'http://localhost:6769', inferenceServerUrl: 'https://inference.askui.com', annotationLevel: AnnotationLevel.DISABLED }, clientArgs));
+export class UiControlClient extends FluentCommand {
+    constructor(httpClient, clientArgs) {
+        super();
+        this.httpClient = httpClient;
+        this.clientArgs = clientArgs;
+        this.secretText = undefined;
+    }
+    static build(clientArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const analytics = new Analytics();
+            const analyticsHeaders = yield analytics.getAnalyticsHeaders();
+            const cas = getClientArgsWithDefaults(clientArgs);
+            const httpClient = new HttpClientGot(cas.credentials || envCredentials(), analyticsHeaders);
+            return new UiControlClient(httpClient, cas);
+        });
+    }
+    get uiControllerClient() {
+        if (!this._uiControllerClient) {
+            this._uiControllerClient = new UiControllerClient(this.clientArgs.uiControllerUrl);
+        }
+        return this._uiControllerClient;
+    }
+    get inferenceClient() {
+        return new InferenceClient(this.clientArgs.inferenceServerUrl, this.httpClient);
+    }
+    get executionRuntime() {
+        return new ExecutionRuntime(this.uiControllerClient, this.inferenceClient);
+    }
+    annotateByDefault(testStepState, customElements = []) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if ((testStepState === TestStepState.FAILED
+                && this.clientArgs.annotationLevel === AnnotationLevel.DISABLED)
+                || (testStepState === TestStepState.PASSED
+                    && this.clientArgs.annotationLevel !== AnnotationLevel.ALL)) {
+                return;
+            }
+            yield this.annotate({
+                customElements,
+                fileNamePrefix: `${testStepState.toLowerCase()}_testStep_annotation`,
+            });
+        });
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const connectionState = yield this.uiControllerClient.connect();
+            return connectionState;
+        });
+    }
+    annotate(annotationRequest = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const annotation = yield this.executionRuntime.annotateImage(annotationRequest.imagePath, annotationRequest.customElements);
+            AnnotationWriter.write(annotation.toHtml(), annotationRequest.outputPath, annotationRequest.fileNamePrefix);
+            return annotation;
+        });
+    }
+    annotateInteractively() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.executionRuntime.annotateInteractively();
+            }
+            catch (err) {
+                logger.error(err);
+            }
+        });
+    }
+    exec(instruction, customElementJson = []) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const customElements = yield CustomElement.fromJsonListWithImagePathOrImage(customElementJson);
+            const { secretText } = this;
+            try {
+                yield this.executionRuntime.executeTestStep({
+                    instruction,
+                    customElements,
+                    secretText,
+                });
+                yield this.annotateByDefault(TestStepState.PASSED, customElements);
+                return yield Promise.resolve();
+            }
+            catch (error) {
+                yield this.annotateByDefault(TestStepState.FAILED, customElements);
+                return Promise.reject(new UiControlClientError(`A problem occures while executing the instruction: ${instruction}. Reason ${error}`));
+            }
+        });
+    }
+    /**
+     * Types a text inside the filtered element.
+     *
+     * By default, the `text` is included in the logs and sent over to the askui Inference server to
+     * predict in which context the typing has to occur. You can exclude the `text` from the logs
+     * and the request to the askui Inference server setting `options.isSecret` to `true`.
+     * This should not change the quality of the prediction of the askui Inference server. In this
+     * case, `options.secretMask` is included in logs and sent over instead of the `text`.
+     *
+     * @param {string} text - A text to type.
+     * @param {Object} [options]
+     * @param {boolean} [options.isSecret = false] - If set to `true`, `text` is neither included in
+     *   logs of askui nor sent over to askui Inference for prediction.
+     * @param {string} [options.secretMask = '****'] - If `options.isSecret` is set to `true`, this
+     *   is included in logs and sent over to askui Inference for prediction instead of the `text`.
+     *
+     * @return {FluentFilters}
+     */
+    typeIn(text, { isSecret = false, secretMask = '****' } = {}) {
+        if (isSecret) {
+            this.secretText = text;
+            return super.typeIn(secretMask);
+        }
+        return super.typeIn(text);
+    }
+    /**
+     * Types a text at the current position.
+     *
+     * By default, the `text` is included in the logs and sent over to the askui Inference server to
+     * predict in which context the typing has to occur. You can exclude the `text` from the logs
+     * and the request to the askui Inference server setting `options.isSecret` to `true`.
+     * This should not change the quality of the prediction of the askui Inference server. In this
+     * case, `options.secretMask` is included in logs and sent over instead of the `text`.
+     *
+     * @param {string} text - A text to type.
+     * @param {Object} options
+     * @param {boolean} [options.isSecret = false] - If set to `true`, `text` is neither included in
+     *   logs of askui nor sent over to askui Inference for prediction.
+     * @param {string} [options.secretMask = '****'] - If `options.isSecret` is set to `true`, this
+     *   is included in logs and sent over to askui Inference for prediction instead of the `text`.
+     *
+     * @return {Exec}
+     */
+    type(text, { isSecret = false, secretMask = '****' } = {}) {
+        if (isSecret) {
+            this.secretText = text;
+            return super.type(secretMask);
+        }
+        return super.type(text);
+    }
+    /**
+     * Waits for `<delayInMs>` ms, e.g., 1000 ms. The exact delay may be a little longer
+     * than `<delayInMs>` but never shorter than that.
+     *
+     * @param {number} delayInMs - The delay in ms to wait for.
+     *
+     * @return {Executable}
+     */
+    // eslint-disable-next-line class-methods-use-this
+    waitFor(delayInMs) {
+        return {
+            exec() {
+                logger.debug(`Wait for ${delayInMs} ms`);
+                return new Promise((resolve) => { setTimeout(() => resolve(), delayInMs); });
+            },
+        };
+    }
+    /**
+    * closes the connection to the controlui-server`.
+    */
+    close() {
+        this.uiControllerClient.close();
+    }
+}

package/dist/esm/execution/{client-connection-state.d.ts → ui-controller-client-connection-state.d.ts}

@@ -1,4 +1,4 @@
-export declare enum ClientConnectionState {
+export declare enum UiControllerClientConnectionState {
     NOT_CONNECTED = 0,
     CONNECTING = 1,
     CONNECTED = 2,

package/dist/esm/execution/ui-controller-client-connection-state.js

@@ -0,0 +1,7 @@
+export var UiControllerClientConnectionState;
+(function (UiControllerClientConnectionState) {
+    UiControllerClientConnectionState[UiControllerClientConnectionState["NOT_CONNECTED"] = 0] = "NOT_CONNECTED";
+    UiControllerClientConnectionState[UiControllerClientConnectionState["CONNECTING"] = 1] = "CONNECTING";
+    UiControllerClientConnectionState[UiControllerClientConnectionState["CONNECTED"] = 2] = "CONNECTED";
+    UiControllerClientConnectionState[UiControllerClientConnectionState["ERROR"] = 3] = "ERROR";
+})(UiControllerClientConnectionState || (UiControllerClientConnectionState = {}));

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

@@ -0,0 +1,27 @@
+import { CredentialArgs } from '../utils/http/credentials';
+import { AnnotationLevel } from './annotation-level';
+/**
+ * Configuration options for the askui UI Control Client
+ *
+ * @param {string} uiControllerUrl - Default: http://localhost:6769
+ * The adress of the askui UI Controller server.
+ * @param {string} inferenceClientUrl - Default: https://inference.askui.com`
+ * Address of the askui Inference server.
+ * @param {AnnotationLevel} annotationLevel - Default: AnnotationLevel.DISABLED
+ * Usage of annotate command
+ * after execution of test steps.
+ * You have three options: `DISABLED`, `ON_FAILURE`, `ALL`.
+ * @param {CredentialArgs} credentials - We need to provide credentials for
+ * the authentication of the askui Inference Server.
+ */
+export interface ClientArgs {
+    readonly uiControllerUrl?: string;
+    readonly inferenceServerUrl?: string;
+    readonly annotationLevel?: AnnotationLevel;
+    readonly credentials?: CredentialArgs;
+}
+export interface ClientArgsWithDefaults extends ClientArgs {
+    readonly uiControllerUrl: string;
+    readonly inferenceServerUrl: string;
+    readonly annotationLevel: AnnotationLevel;
+}

package/dist/esm/execution/{control-your-ui-client.d.ts → ui-controller-client.d.ts}

@@ -2,21 +2,21 @@ import WebSocket from 'ws';
 import { DetectedElement } from '../core/model/annotation-result/detected-element';
 import { CaptureScreenshotResponse, ControlResponse, StartRecordingResponse, StopRecordingResponse, ReadRecordingPartResponse, InteractiveAnnotationResponse, GetProcessPidResponse } from '../core/runner-protocol';
 import { ControlCommand } from '../core/ui-control-commands';
-import { ClientConnectionState } from './client-connection-state';
-export declare class ControlYourUiClient {
-    controlServerUrl: string;
+import { UiControllerClientConnectionState } from './ui-controller-client-connection-state';
+export declare class UiControllerClient {
+    url: string;
     private static readonly EMPTY_REJECT;
     private static readonly EMPTY_RESOLVE;
     private static readonly REQUEST_TIMEOUT_IN_MS;
     ws: WebSocket;
-    connectionState: ClientConnectionState;
+    connectionState: UiControllerClientConnectionState;
     private timeout?;
     private currentReject;
     private currentResolve;
-    constructor(controlServerUrl: string);
+    constructor(url: string);
     private clearResponse;
     private onMessage;
-    connect(): Promise<ClientConnectionState>;
+    connect(): Promise<UiControllerClientConnectionState>;
     close(): void;
     private sendAndReceive;
     private send;