askui 0.3.2 → 0.5.0

package/dist/cjs/execution/dsl.spec.js

@@ -12,7 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const dsl_1 = require("./dsl");
 class TestCommand extends dsl_1.FluentCommand {
     // eslint-disable-next-line class-methods-use-this
-    exec(instruction, customElements) {
+    fluentCommandExecutor(instruction, customElements) {
         return __awaiter(this, void 0, void 0, function* () {
             // eslint-disable-next-line no-console
             console.log(`${instruction} ${customElements}`);
@@ -24,14 +24,14 @@ describe('DSL', () => {
     describe('custom element', () => {
         test('should call exec function with zero custom element', () => __awaiter(void 0, void 0, void 0, function* () {
             const underTest = new TestCommand();
-            const testCommandSpy = jest.spyOn(underTest, 'exec');
+            const testCommandSpy = jest.spyOn(underTest, 'fluentCommandExecutor');
             yield underTest.click().button()
                 .exec();
             expect(testCommandSpy).toHaveBeenCalledWith('Click on button', []);
         }));
         test('should call exec function with one custom element', () => __awaiter(void 0, void 0, void 0, function* () {
             const underTest = new TestCommand();
-            const testCommandSpy = jest.spyOn(underTest, 'exec');
+            const testCommandSpy = jest.spyOn(underTest, 'fluentCommandExecutor');
             yield underTest.click().customElement({
                 customImage: 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z/C/HgAGgwJ/lK3Q6wAAAABJRU5ErkJggg==',
                 imageCompareFormat: 'grayscale',
@@ -46,7 +46,7 @@ describe('DSL', () => {
         }));
         test('should call exec function with two custom element', () => __awaiter(void 0, void 0, void 0, function* () {
             const underTest = new TestCommand();
-            const testCommandSpy = jest.spyOn(underTest, 'exec');
+            const testCommandSpy = jest.spyOn(underTest, 'fluentCommandExecutor');
             yield underTest.click().customElement({
                 customImage: 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z/C/HgAGgwJ/lK3Q6wAAAABJRU5ErkJggg==',
                 imageCompareFormat: 'grayscale',

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

@@ -3,6 +3,7 @@ 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';
+import { DetectedElement } from '../core/model/annotation-result/detected-element';
 export declare class ExecutionRuntime {
     private uiControllerClient;
     private inferenceClient;
@@ -25,5 +26,6 @@ export declare class ExecutionRuntime {
     private predictCommand;
     annotateInteractively(): Promise<void>;
     takeScreenshotIfImageisNotProvided(imagePath?: string): Promise<string>;
+    getDetectedElements(instruction: string, customElementJson?: CustomElementJson[]): Promise<DetectedElement[]>;
     annotateImage(imagePath?: string, customElementJson?: CustomElementJson[]): Promise<Annotation>;
 }

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

@@ -119,7 +119,7 @@ class ExecutionRuntime {
     annotateInteractively() {
         return __awaiter(this, void 0, void 0, function* () {
             const annotationResponse = yield this.annotateImage();
-            yield this.uiControllerClient.annotateInteractively(annotationResponse.objects, annotationResponse.image);
+            yield this.uiControllerClient.annotateInteractively(annotationResponse.detected_elements, annotationResponse.image);
         });
     }
     takeScreenshotIfImageisNotProvided(imagePath) {
@@ -135,6 +135,16 @@ class ExecutionRuntime {
             return base64Image;
         });
     }
+    getDetectedElements(instruction, customElementJson) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let customElements = [];
+            const base64Image = yield this.takeScreenshotIfImageisNotProvided();
+            if (customElementJson !== undefined) {
+                customElements = yield test_case_dto_1.CustomElement.fromJsonListWithImagePathOrImage(customElementJson);
+            }
+            return this.inferenceClient.getDetectedElements(instruction, base64Image, customElements);
+        });
+    }
     annotateImage(imagePath, customElementJson) {
         return __awaiter(this, void 0, void 0, function* () {
             let customElements = [];

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

@@ -2,6 +2,7 @@ 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';
+import { DetectedElement } from '../core/model/annotation-result/detected-element';
 export declare class InferenceClient {
     baseUrl: string;
     httpClient: HttpClientGot;
@@ -11,6 +12,8 @@ export declare class InferenceClient {
     constructor(baseUrl: string, httpClient: HttpClientGot, workspaceId?: string | undefined, apiVersion?: string);
     isImageRequired(instruction: string): Promise<boolean>;
     private resizeIfNeeded;
+    inference(customElements?: CustomElement[], image?: string, instruction?: string): Promise<ControlCommand | Annotation>;
     predictControlCommand(instruction: string, customElements?: CustomElement[], image?: string): Promise<ControlCommand>;
+    getDetectedElements(instruction: string, image: string, customElements?: CustomElement[]): Promise<DetectedElement[]>;
     predictImageAnnotation(image: string, customElements?: CustomElement[]): Promise<Annotation>;
 }

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

@@ -17,8 +17,9 @@ const url_join_1 = __importDefault(require("url-join"));
 const ui_control_commands_1 = require("../core/ui-control-commands");
 const annotation_1 = require("../core/annotation/annotation");
 const transformations_1 = require("../utils/transformations");
+const inference_response_error_1 = require("./inference-response-error");
 class InferenceClient {
-    constructor(baseUrl, httpClient, workspaceId, apiVersion = 'v2') {
+    constructor(baseUrl, httpClient, workspaceId, apiVersion = 'v3') {
         this.baseUrl = baseUrl;
         this.httpClient = httpClient;
         this.workspaceId = workspaceId;
@@ -45,7 +46,7 @@ class InferenceClient {
             return (0, transformations_1.resizeBase64ImageWithSameRatio)(image);
         });
     }
-    predictControlCommand(instruction, customElements = [], image) {
+    inference(customElements = [], image, instruction) {
         return __awaiter(this, void 0, void 0, function* () {
             const resizedImage = yield this.resizeIfNeeded(customElements, image);
             const httpBody = {
@@ -53,21 +54,36 @@ class InferenceClient {
                 instruction,
                 customElements,
             };
-            const url = (0, url_join_1.default)(this.url, 'predict-command');
+            const url = (0, url_join_1.default)(this.url, 'inference');
             const httpResponse = yield this.httpClient.post(url, httpBody);
-            return ui_control_commands_1.ControlCommand.fromJson(httpResponse, resizedImage.resizeRatio);
+            return ui_control_commands_1.InferenceResponse.fromJson(httpResponse, resizedImage.resizeRatio, image);
+        });
+    }
+    predictControlCommand(instruction, customElements = [], image) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const inferenceResponse = yield this.inference(customElements, image, instruction);
+            if (!(inferenceResponse instanceof ui_control_commands_1.ControlCommand)) {
+                throw new inference_response_error_1.InferenceResponseError('Internal Error. Can not execute command');
+            }
+            return inferenceResponse;
+        });
+    }
+    getDetectedElements(instruction, image, customElements = []) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const inferenceResponse = yield this.inference(customElements, image, instruction);
+            if (!(inferenceResponse instanceof annotation_1.Annotation)) {
+                throw new inference_response_error_1.InferenceResponseError('Internal Error. Unable to get the detected elements');
+            }
+            return inferenceResponse.detected_elements;
         });
     }
     predictImageAnnotation(image, customElements = []) {
         return __awaiter(this, void 0, void 0, function* () {
-            const resizedImage = yield this.resizeIfNeeded(customElements, image);
-            const httpBody = {
-                image: resizedImage.base64Image,
-                customElements,
-            };
-            const url = (0, url_join_1.default)(this.url, 'annotate', '?format=json');
-            const httpResponse = yield this.httpClient.post(url, httpBody);
-            return annotation_1.Annotation.fromJson(Object.assign(Object.assign({}, httpResponse), { image }), resizedImage.resizeRatio);
+            const inferenceResponse = yield this.inference(customElements, image);
+            if (!(inferenceResponse instanceof annotation_1.Annotation)) {
+                throw new inference_response_error_1.InferenceResponseError('Internal Error. Can not execute annotation');
+            }
+            return inferenceResponse;
         });
     }
 }

package/dist/cjs/execution/inference-response-error.d.ts

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

package/dist/cjs/execution/inference-response-error.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InferenceResponseError = void 0;
+class InferenceResponseError extends Error {
+}
+exports.InferenceResponseError = InferenceResponseError;

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

@@ -1,10 +1,11 @@
 import { CustomElementJson } from '../core/model/test-case-dto';
-import { Exec, Executable, FluentCommand, FluentFilters } from './dsl';
+import { Exec, Executable, FluentFilters, ApiCommands } 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 {
+import { DetectedElement } from '../core/model/annotation-result/detected-element';
+export declare class UiControlClient extends ApiCommands {
     private httpClient;
     private clientArgs;
     private workspaceId?;
@@ -19,7 +20,8 @@ export declare class UiControlClient extends FluentCommand {
     annotate(annotationRequest?: AnnotationRequest): Promise<Annotation>;
     annotateInteractively(): Promise<void>;
     private escapeSeparatorString;
-    exec(instruction: string, customElementJson?: CustomElementJson[]): Promise<void>;
+    fluentCommandExecutor(instruction: string, customElementJson?: CustomElementJson[]): Promise<void>;
+    getterExecutor(instruction: string, customElementJson?: CustomElementJson[]): Promise<DetectedElement[]>;
     private secretText;
     /**
      * Types a text inside the filtered element.

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

@@ -24,7 +24,7 @@ const ui_control_client_error_1 = require("./ui-control-client-error");
 const read_environment_credentials_1 = require("./read-environment-credentials");
 const analytics_1 = require("../utils/analytics");
 const getClientArgsWithDefaults = (clientArgs = {}) => (Object.assign({ uiControllerUrl: 'http://127.0.0.1:6769', inferenceServerUrl: 'https://inference.askui.com', annotationLevel: annotation_level_1.AnnotationLevel.DISABLED }, clientArgs));
-class UiControlClient extends dsl_1.FluentCommand {
+class UiControlClient extends dsl_1.ApiCommands {
     constructor(httpClient, clientArgs, workspaceId) {
         super();
         this.httpClient = httpClient;
@@ -96,7 +96,7 @@ class UiControlClient extends dsl_1.FluentCommand {
     escapeSeparatorString(instruction) {
         return instruction.split(dsl_1.Separators.STRING).join('"');
     }
-    exec(instruction, customElementJson = []) {
+    fluentCommandExecutor(instruction, customElementJson = []) {
         return __awaiter(this, void 0, void 0, function* () {
             const { secretText } = this;
             const customElements = yield test_case_dto_1.CustomElement.fromJsonListWithImagePathOrImage(customElementJson);
@@ -117,6 +117,14 @@ class UiControlClient extends dsl_1.FluentCommand {
             }
         });
     }
+    getterExecutor(instruction, customElementJson = []) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const customElements = yield test_case_dto_1.CustomElement.fromJsonListWithImagePathOrImage(customElementJson);
+            const stringWithoutSeparators = this.escapeSeparatorString(instruction);
+            logger_1.logger.debug(stringWithoutSeparators);
+            return this.executionRuntime.getDetectedElements(instruction, customElements);
+        });
+    }
     /**
      * Types a text inside the filtered element.
      *

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

@@ -1,4 +1,13 @@
 "use strict";
+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());
+    });
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -8,14 +17,36 @@ const commander_1 = require("commander");
 const path_1 = __importDefault(require("path"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_2 = require("../utils/path");
+const logger_1 = require("./logger");
 const createProgram = () => {
     const program = new commander_1.Command('askui');
     program.usage('<command> [options]');
     return program;
 };
-function copyExampleProject() {
-    const exampleProjectPath = path_1.default.join('example_projects_templates', 'typescript_jest');
-    fs_extra_1.default.copySync(path_1.default.join((0, path_2.getPathToNodeModulesRoot)(), exampleProjectPath), '.');
+function replaceStringInFile(filePath, replace, replacement) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const data = yield fs_extra_1.default.readFile(filePath, 'utf8');
+            const result = data.replace(replace, replacement);
+            yield fs_extra_1.default.writeFile(filePath, result, 'utf8');
+        }
+        catch (error) {
+            logger_1.logger.error(`Could not replace '${replace}' with '${replacement}' in file '${path_1.default}'`);
+            logger_1.logger.error(error.message);
+        }
+    });
+}
+function copyExampleProject(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const exampleProjectPath = path_1.default.join('example_projects_templates', 'typescript_jest');
+        fs_extra_1.default.copySync(path_1.default.join((0, path_2.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']);
+        }
+    });
 }
 function init(argv) {
     const args = argv || process.argv;
@@ -23,7 +54,12 @@ 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);
 }
 exports.init = init;

package/dist/cjs/utils/http/http-client-got.js

@@ -15,6 +15,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpClientGot = void 0;
 const got_1 = __importDefault(require("got"));
 const tough_cookie_1 = require("tough-cookie");
+const lib_1 = require("../../lib");
 const credentials_1 = require("./credentials");
 const custom_errors_1 = require("./custom-errors");
 class HttpClientGot {
@@ -39,7 +40,10 @@ class HttpClientGot {
     post(url, data) {
         return __awaiter(this, void 0, void 0, function* () {
             const options = this.injectHeadersAndCookies(url, { json: data, responseType: 'json', throwHttpErrors: false });
-            const { body, statusCode } = yield got_1.default.post(url, options);
+            const { body, statusCode, headers } = yield got_1.default.post(url, options);
+            if (headers['deprecation'] !== undefined) {
+                lib_1.logger.warn(headers['deprecation']);
+            }
             if (statusCode !== 200) {
                 throw (0, custom_errors_1.httpClientErrorHandler)(statusCode, JSON.stringify(body));
             }

package/dist/esm/core/annotation/annotation-writer.js

@@ -4,10 +4,8 @@ import { logger } from '../../lib/logger';
 export class AnnotationWriter {
     static write(html, outputFolder = 'report', fileNamePrefix = 'annotation') {
         const currentDateTime = new Date();
-        const formattedTime = `${currentDateTime.getDay()}-${currentDateTime.getMonth()}`
-            + `-${currentDateTime.getFullYear()}_${currentDateTime.getHours()}`
-            + `-${currentDateTime.getMinutes()}-${currentDateTime.getSeconds()}`;
-        const fileName = `${fileNamePrefix}_${formattedTime}.html`;
+        const currentTimeStringOnlyNumbers = currentDateTime.toISOString().replace(/\D/g, '');
+        const fileName = `${currentTimeStringOnlyNumbers}_${fileNamePrefix}.html`;
         const outputFilePath = path.join(outputFolder, fileName);
         if (!(fs.existsSync(outputFolder))) {
             fs.mkdirSync(outputFolder, { recursive: true });

package/dist/esm/core/annotation/annotation.d.ts

@@ -1,11 +1,10 @@
 import { JSDOM } from 'jsdom';
 import { DetectedElement } from '../model/annotation-result/detected-element';
-import { AnnotationJson } from './annotation-json';
 export declare class Annotation {
     image: string;
-    objects: DetectedElement[];
-    constructor(image: string, objects?: DetectedElement[]);
+    detected_elements: DetectedElement[];
+    constructor(image: string, detected_elements?: DetectedElement[]);
     toHtml(): JSDOM;
-    static fromJson(json: AnnotationJson, resizeRatio?: number): Annotation;
+    static fromJson(json: unknown, resizeRatio?: number): Annotation;
     private static getHtmlTemplate;
 }

package/dist/esm/core/annotation/annotation.js

@@ -3,9 +3,9 @@ import path from 'path';
 import { JSDOM } from 'jsdom';
 import { DetectedElement } from '../model/annotation-result/detected-element';
 export class Annotation {
-    constructor(image, objects = []) {
+    constructor(image, detected_elements = []) {
         this.image = image;
-        this.objects = objects;
+        this.detected_elements = detected_elements;
     }
     toHtml() {
         const template = Annotation.getHtmlTemplate();
@@ -14,13 +14,14 @@ export class Annotation {
       var el = document.getElementsByTagName("bounding-box-renderer");
       el[0].setAttribute("shouldrenderimage", true);
       el[0].setAttribute("imagestr", "${this.image.trim()}"); 
-      el[0].setAttribute("detectedobjects", JSON.stringify(${JSON.stringify(this.objects)}));
+      el[0].setAttribute("detectedobjects", JSON.stringify(${JSON.stringify(this.detected_elements)}));
     `;
         template.window.document.body.appendChild(script);
         return template;
     }
     static fromJson(json, resizeRatio = 1) {
-        return new Annotation(json.image, json.objects.map((object) => DetectedElement.fromJson(object, resizeRatio)));
+        const annotation = json;
+        return new Annotation(annotation.image, annotation.detected_elements.map((data) => DetectedElement.fromJson(data, resizeRatio)));
     }
     static getHtmlTemplate() {
         const templatePath = path.join(__dirname, 'template.html');

package/dist/esm/core/inference-response/inference-response.d.ts

@@ -0,0 +1,15 @@
+import { ControlCommand } from '../ui-control-commands/control-command';
+import { Annotation } from '../annotation/annotation';
+export declare class InferenceResponse {
+    type: string;
+    data: ControlCommand | Annotation;
+    constructor(type: string, data: ControlCommand | Annotation);
+    static fromJson(json: unknown, resizeRatio?: number, image?: string): ControlCommand | Annotation;
+    static createModels(type: string, data: ControlCommand | Annotation, resizeRatio: number, image?: string): ControlCommand | Annotation;
+    static models: Models;
+}
+interface Models {
+    DETECTED_ELEMENTS: CallableFunction;
+    COMMANDS: CallableFunction;
+}
+export {};

package/dist/esm/core/inference-response/inference-response.js

@@ -0,0 +1,21 @@
+import { ControlCommand } from '../ui-control-commands/control-command';
+import { Annotation } from '../annotation/annotation';
+export class InferenceResponse {
+    constructor(type, data) {
+        this.type = type;
+        this.data = data;
+    }
+    static fromJson(json, resizeRatio = 1, image) {
+        const inferenceResponse = json;
+        return this.createModels(inferenceResponse.type, inferenceResponse.data, resizeRatio, image);
+    }
+    static createModels(type, data, resizeRatio, image) {
+        return this.models[type](data, resizeRatio, image);
+    }
+}
+InferenceResponse.models = {
+    DETECTED_ELEMENTS: (data, resizeRatio, image) => Annotation
+        .fromJson({ image, detected_elements: data.detected_elements }, resizeRatio),
+    COMMANDS: (data, resizeRatio) => ControlCommand
+        .fromJson(data, resizeRatio),
+};

package/dist/esm/core/model/annotation-result/boundary-box.d.ts

@@ -1,3 +1,14 @@
+/**
+*
+* @remarks
+* The screen top left corner is the origin
+*
+* @param {number} xmin - The bounding box xmin coordinate in pixels
+* @param {number} ymin - The bounding box ymin coordinate in pixels
+* @param {number} xmax - The bounding box xmax coordinate in pixels
+* @param {number} ymax - The bounding box ymax coordinate in pixels
+*
+*/
 export declare class BoundingBox {
     xmin: number;
     ymin: number;
@@ -5,4 +16,16 @@ export declare class BoundingBox {
     ymax: number;
     constructor(xmin: number, ymin: number, xmax: number, ymax: number);
     static fromJson(boundinBox: BoundingBox, resizeRatio?: number): BoundingBox;
+    /**
+    *
+    * @returns {number} The bounding box height in pixels
+    *
+    */
+    get_height(): number;
+    /**
+    *
+    * @returns {number} The bounding box width in pixels
+    *
+    */
+    get_width(): number;
 }

package/dist/esm/core/model/annotation-result/boundary-box.js

@@ -1,3 +1,14 @@
+/**
+*
+* @remarks
+* The screen top left corner is the origin
+*
+* @param {number} xmin - The bounding box xmin coordinate in pixels
+* @param {number} ymin - The bounding box ymin coordinate in pixels
+* @param {number} xmax - The bounding box xmax coordinate in pixels
+* @param {number} ymax - The bounding box ymax coordinate in pixels
+*
+*/
 export class BoundingBox {
     constructor(xmin, ymin, xmax, ymax) {
         this.xmin = xmin;
@@ -8,4 +19,20 @@ export class BoundingBox {
     static fromJson(boundinBox, resizeRatio = 1) {
         return new BoundingBox(boundinBox.xmin * resizeRatio, boundinBox.ymin * resizeRatio, boundinBox.xmax * resizeRatio, boundinBox.ymax * resizeRatio);
     }
+    /**
+    *
+    * @returns {number} The bounding box height in pixels
+    *
+    */
+    get_height() {
+        return this.ymax - this.ymin;
+    }
+    /**
+    *
+    * @returns {number} The bounding box width in pixels
+    *
+    */
+    get_width() {
+        return this.xmax - this.xmin;
+    }
 }

package/dist/esm/core/model/annotation-result/detected-element.d.ts

@@ -1,11 +1,17 @@
 import { BoundingBox } from './boundary-box';
+/**
+*
+* @param {string} name - The element type e.g text, button
+* @param {string} text - The detected text inside the element
+* @param {string[]} colors - The element top 3 dominate colors
+* @param {BoundingBox} bndbox - The element bounding box
+*
+*/
 export declare class DetectedElement {
     name: string;
-    truncated: number;
-    difficult: number;
     text: string;
     colors: string[];
     bndbox: BoundingBox;
-    constructor(name: string, truncated: number, difficult: number, text: string, colors: string[], bndbox: BoundingBox);
+    constructor(name: string, text: string, colors: string[], bndbox: BoundingBox);
     static fromJson(detectedElement: DetectedElement, resizeRatio?: number): DetectedElement;
 }

package/dist/esm/core/model/annotation-result/detected-element.js

@@ -1,14 +1,20 @@
 import { BoundingBox } from './boundary-box';
+/**
+*
+* @param {string} name - The element type e.g text, button
+* @param {string} text - The detected text inside the element
+* @param {string[]} colors - The element top 3 dominate colors
+* @param {BoundingBox} bndbox - The element bounding box
+*
+*/
 export class DetectedElement {
-    constructor(name, truncated, difficult, text, colors, bndbox) {
+    constructor(name, text, colors, bndbox) {
         this.name = name;
-        this.truncated = truncated;
-        this.difficult = difficult;
         this.text = text;
         this.colors = colors;
         this.bndbox = bndbox;
     }
     static fromJson(detectedElement, resizeRatio = 1) {
-        return new DetectedElement(detectedElement.name, detectedElement.truncated, detectedElement.difficult, detectedElement.text, detectedElement.colors, BoundingBox.fromJson(detectedElement.bndbox, resizeRatio));
+        return new DetectedElement(detectedElement.name, detectedElement.text, detectedElement.colors, BoundingBox.fromJson(detectedElement.bndbox, resizeRatio));
     }
 }

package/dist/esm/core/ui-control-commands/control-command.d.ts

@@ -5,6 +5,6 @@ export declare class ControlCommand {
     actions: Action[];
     tryToRepeat: boolean;
     constructor(code: ControlCommandCode, actions: Action[], tryToRepeat?: boolean);
-    static fromJson(json: ControlCommand, resizeRatio?: number): ControlCommand;
+    static fromJson(json: unknown, resizeRatio?: number): ControlCommand;
     setTextToBeTyped(text: string): void;
 }

package/dist/esm/core/ui-control-commands/control-command.js

@@ -8,7 +8,8 @@ export class ControlCommand {
         this.tryToRepeat = tryToRepeat;
     }
     static fromJson(json, resizeRatio = 1) {
-        return new ControlCommand(ControlCommandCode[json.code], json.actions.map((action) => Action.fromJson(action, resizeRatio)), json.tryToRepeat);
+        const controlCommand = json;
+        return new ControlCommand(ControlCommandCode[controlCommand.code], controlCommand.actions.map((action) => Action.fromJson(action, resizeRatio)), controlCommand.tryToRepeat);
     }
     setTextToBeTyped(text) {
         this.actions = this.actions.map((action) => ([InputEvent.TYPE, InputEvent.TYPE_TEXT].includes(action.inputEvent)

package/dist/esm/core/ui-control-commands/index.d.ts

@@ -1,2 +1,3 @@
 export { ControlCommand } from './control-command';
 export { ControlCommandCode } from './control-command-code';
+export { InferenceResponse } from '../inference-response/inference-response';

package/dist/esm/core/ui-control-commands/index.js

@@ -1,2 +1,3 @@
 export { ControlCommand } from './control-command';
 export { ControlCommandCode } from './control-command-code';
+export { InferenceResponse } from '../inference-response/inference-response';