askui 0.11.3 → 0.11.4

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

@@ -1,6 +1,8 @@
 import { CustomElementJson } from '../custom-element-json';
+import { DetectedElement } from './detected-element';
 export interface AnnotationRequest {
     imagePath?: string;
+    elements?: DetectedElement[];
     outputPath?: string;
     fileNamePrefix?: string;
     customElements?: CustomElementJson[];

package/dist/esm/core/model/test-case-dto/custom-element-json.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Defines a 'custom element'. This is a UI element which is defined by
+ * providing an image and other parameters such as degree of rotation.
+ * It allows filtering for a UI element that is not recognized
+ * by our machine learning models by default.
+ * It can also be used for pixel assertions of elements using classical
+ * [template matching](https://en.wikipedia.org/wiki/Template_matching).
+ *
+ * **Important:** The `CustomElementJson` needs to capture as accurately as possible
+ * what the custom element looks like during test execution as otherwise
+ * our machine learning models cannot find it, even with the additional data
+ * provided. This is especially true for the resolution used while cropping
+ * the `CustomElementJson.customImage` which should match the resolution during
+ * test execution.
+ *
+ * Rotated custom elements can be filtered for using
+ * `CustomElementJson.rotationDegreePerStep`.
+ */
+export interface CustomElementJson {
+    /**
+     * An cropped image in form of a base64 string or file path,
+     * e.g., "./custom.png".
+     */
+    customImage: string;
+    /**
+     * A unique name which can be used for filtering for the custom element,
+     * e.g.,
+     * ```typescript
+     * ...customElement({
+     *   name: 'unique-name',
+     *   // ... (rest of the custom element)
+     * }).withText('unique-name')
+     * ```
+     *
+     * If not set, the text inside the custom element is
+     * detected via
+     * [OCR](https://en.wikipedia.org/wiki/Optical_character_recognition).
+     * It can also be used for filtering for the custom element.
+     */
+    name?: string | undefined;
+    /**
+     * A threshold for how similar UI elements shown during test execution
+     * need to be to the custom element as defined by the other fields in
+     * `CustomElementJson` to be recognized as such. Takes values between
+     * `0.0` (= all elements are recognized as the custom element which is
+     * probably not what you want) and `1.0` (= elements need to look exactly
+     * like defined by `CustomElementJson` which is unlikely to be achieved
+     * as even minor differences count). Defaults to `0.9`.
+     */
+    threshold?: number | undefined;
+    /**
+     * A step size in rotation degree. Rotates the custom image by
+     * `rotationDegreePerStep` until 360° is exceeded. Range is between
+     * 0° - 360°. Defaults to 0°.
+     *
+     * **Important**: This increases the prediction time quite a bit. So only use
+     * it when absolutely necessary.
+     */
+    rotationDegreePerStep?: number | undefined;
+    /**
+     * A color compare style. Allows matching a custom element by color, e.g.,
+     * instead of filtering for all icons (blue and green ones),
+     * only the green ones captured by `customImage` are filtered for using 'RGB'.
+     * Defaults to 'grayscale'.
+     *
+     * **Important**: This increases the prediction time quite a bit. So only use
+     * it when absolutely necessary.
+     */
+    imageCompareFormat?: 'RGB' | 'grayscale' | undefined;
+    /** A polygon to match only a certain area of the custom element. */
+    mask?: ({
+        x: number;
+        y: number;
+    })[] | undefined;
+}

package/dist/esm/core/model/test-case-dto/custom-element.d.ts

@@ -0,0 +1,21 @@
+import { CustomElementJson } from './custom-element-json';
+export declare class CustomElement implements CustomElementJson {
+    customImage: string;
+    name?: string | undefined;
+    threshold?: number | undefined;
+    rotationDegreePerStep?: number | undefined;
+    imageCompareFormat?: "RGB" | "grayscale" | undefined;
+    mask?: {
+        x: number;
+        y: number;
+    }[] | undefined;
+    private static schema;
+    constructor(customImage: string, name?: string | undefined, threshold?: number | undefined, rotationDegreePerStep?: number | undefined, imageCompareFormat?: "RGB" | "grayscale" | undefined, mask?: {
+        x: number;
+        y: number;
+    }[] | undefined);
+    static fromJsonListWithImagePathOrImage(ceJson?: CustomElementJson[]): Promise<CustomElement[]>;
+    static fromJsonWithImagePathOrImage(ceJson: CustomElementJson): Promise<CustomElement>;
+    static fromJson(ceJson: CustomElementJson): CustomElement;
+    validate(): void;
+}

package/dist/esm/core/model/test-case-dto/custom-element.js

@@ -0,0 +1,50 @@
+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 { array, number, object, ValidationError, } from 'yup';
+import { Base64Image } from '../../../utils/base_64_image/base-64-image';
+export class CustomElement {
+    constructor(customImage, name, threshold, rotationDegreePerStep, imageCompareFormat, mask) {
+        this.customImage = customImage;
+        this.name = name;
+        this.threshold = threshold;
+        this.rotationDegreePerStep = rotationDegreePerStep;
+        this.imageCompareFormat = imageCompareFormat;
+        this.mask = mask;
+    }
+    static fromJsonListWithImagePathOrImage(ceJson = []) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Promise.all(ceJson.map((customElement) => CustomElement.fromJsonWithImagePathOrImage(customElement)));
+        });
+    }
+    static fromJsonWithImagePathOrImage(ceJson) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const customImage = (yield Base64Image.fromPathOrString(ceJson.customImage)).toString();
+            const customElement = CustomElement.fromJson(Object.assign(Object.assign({}, ceJson), { customImage }));
+            customElement.validate();
+            return customElement;
+        });
+    }
+    static fromJson(ceJson) {
+        return new CustomElement(ceJson.customImage, ceJson.name, ceJson.threshold, ceJson.rotationDegreePerStep, ceJson.imageCompareFormat, ceJson.mask);
+    }
+    validate() {
+        try {
+            CustomElement.schema.validateSync(this, { abortEarly: false, strict: true });
+        }
+        catch (e) { // ValidationError
+            throw new ValidationError(e.errors.join(', '));
+        }
+    }
+}
+CustomElement.schema = object({
+    threshold: number().optional().min(0).max(1),
+    rotationDegreePerStep: number().optional().min(0).lessThan(360),
+    mask: array().optional().min(3, 'mask must contain at least 3 points'),
+});

package/dist/esm/core/model/test-case-dto/index.d.ts

@@ -0,0 +1,3 @@
+export { CustomElement } from './custom-element';
+export { CustomElementJson } from './custom-element-json';
+export { TestStep } from './test-step';

package/dist/esm/core/model/test-case-dto/index.js

@@ -0,0 +1 @@
+export { CustomElement } from './custom-element';

package/dist/esm/core/model/test-case-dto/test-step.d.ts

@@ -0,0 +1,6 @@
+import { CustomElement } from './custom-element';
+export interface TestStep {
+    instruction: string;
+    customElements?: CustomElement[];
+    secretText?: string | undefined;
+}

package/dist/esm/core/model/test-case-result-dto/index.d.ts

@@ -0,0 +1,2 @@
+export { TestStepResultDto } from './test-step-result-dto';
+export { TestStepState } from './test-step-state';

package/dist/esm/core/model/test-case-result-dto/index.js

@@ -0,0 +1,2 @@
+export { TestStepResultDto } from './test-step-result-dto';
+export { TestStepState } from './test-step-state';

package/dist/esm/core/model/test-case-result-dto/test-step-result-dto.d.ts

@@ -0,0 +1,9 @@
+import { TestStepState } from './test-step-state';
+export declare class TestStepResultDto {
+    state: TestStepState;
+    comment: string;
+    createDate: Date;
+    updateDate: Date;
+    constructor(state: TestStepState, comment?: string, createDate?: Date, updateDate?: Date);
+    static fromJson(testStepResult: TestStepResultDto): TestStepResultDto;
+}

package/dist/esm/core/model/test-case-result-dto/test-step-result-dto.js

@@ -0,0 +1,12 @@
+import { TestStepState } from './test-step-state';
+export class TestStepResultDto {
+    constructor(state, comment = '', createDate = new Date(), updateDate = new Date()) {
+        this.state = state;
+        this.comment = comment;
+        this.createDate = createDate;
+        this.updateDate = updateDate;
+    }
+    static fromJson(testStepResult) {
+        return new TestStepResultDto(TestStepState[testStepResult.state], testStepResult.comment, new Date(testStepResult.createDate), new Date(testStepResult.updateDate));
+    }
+}

package/dist/esm/core/model/test-case-result-dto/test-step-state.d.ts

@@ -0,0 +1,4 @@
+export declare enum TestStepState {
+    PASSED = "PASSED",
+    FAILED = "FAILED"
+}

package/dist/esm/core/model/test-case-result-dto/test-step-state.js

@@ -0,0 +1,5 @@
+export var TestStepState;
+(function (TestStepState) {
+    TestStepState["PASSED"] = "PASSED";
+    TestStepState["FAILED"] = "FAILED";
+})(TestStepState || (TestStepState = {}));

package/dist/esm/execution/control-command-error.d.ts

@@ -1,3 +1,7 @@
 export declare class ControlCommandError extends Error {
+    matcherResult: {
+        pass: boolean;
+        message: string;
+    };
     constructor(message: string);
 }

package/dist/esm/execution/control-command-error.js

@@ -2,5 +2,9 @@ export class ControlCommandError extends Error {
     constructor(message) {
         super(message);
         this.name = 'ControlCommandError';
+        this.matcherResult = {
+            pass: false,
+            message,
+        };
     }
 }

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

@@ -34,5 +34,5 @@ export declare class ExecutionRuntime {
     annotateInteractively(): Promise<void>;
     takeScreenshotIfImageisNotProvided(imagePath?: string): Promise<string>;
     getDetectedElements(instruction: string, customElementJson?: CustomElementJson[]): Promise<DetectedElement[]>;
-    annotateImage(imagePath?: string, customElementJson?: CustomElementJson[]): Promise<Annotation>;
+    annotateImage(imagePath?: string, customElementJson?: CustomElementJson[], elements?: DetectedElement[]): Promise<Annotation>;
 }

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

@@ -12,6 +12,7 @@ import { CustomElement } from '../core/model/custom-element';
 import { RepeatError } from './repeat-error';
 import { delay } from './misc';
 import { ControlCommandError } from './control-command-error';
+import { Annotation } from '../core/annotation/annotation';
 import { logger } from '../lib/logger';
 import { Base64Image } from '../utils/base_64_image/base-64-image';
 export class ExecutionRuntime {
@@ -188,10 +189,16 @@ export class ExecutionRuntime {
             return this.inferenceClient.getDetectedElements(instruction, base64Image, customElements);
         });
     }
-    annotateImage(imagePath, customElementJson) {
+    annotateImage(imagePath, customElementJson, elements) {
         return __awaiter(this, void 0, void 0, function* () {
             let customElements = [];
             const base64Image = yield this.takeScreenshotIfImageisNotProvided(imagePath);
+            if (elements !== undefined) {
+                if (elements.length === 0) {
+                    logger.warn("Parameter 'elements' is an empty list.");
+                }
+                return new Annotation(base64Image, elements);
+            }
             if (customElementJson !== undefined) {
                 customElements = yield CustomElement.fromJsonListWithImagePathOrImage(customElementJson);
             }

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

@@ -0,0 +1,132 @@
+import { DetectedElement } from "@/core/model/annotation-result/detected-element";
+import { CustomElement } from "@/core/model/custom-element";
+export interface Snapshot {
+    readonly createdAt: Date;
+    readonly screenshot?: string | undefined;
+    readonly detectedElements?: Readonly<Readonly<DetectedElement>>[] | undefined;
+}
+export interface Instruction {
+    readonly value: string;
+    readonly valueHumanReadable: string;
+    readonly customElements?: Readonly<Readonly<CustomElement>>[];
+    readonly secretText?: string | undefined;
+}
+export interface Step {
+    readonly instruction: Readonly<Instruction>;
+    readonly status: StepStatus;
+    /**
+     * A snapshot of the state of the screen before the step is ran which is nearly immediately after the call to `.exec()`
+     */
+    readonly begin?: Snapshot | undefined;
+    /**
+     * The duration of the step in milliseconds based on the start and end time. If the step is still running, this property is undefined.
+     */
+    readonly duration?: number | undefined;
+    /**
+     * A snapshot of the state of the screen after the step has been run. If the step is still running or still pending, this property is undefined.
+     */
+    readonly end?: Snapshot | undefined;
+    /**
+     * When a step failed or is erroneous, this property contains the error.
+     */
+    readonly error?: Error | undefined;
+    readonly runs: Readonly<StepRun[]>;
+    readonly retries: Readonly<StepRun[]>;
+    readonly retryCount: number;
+    readonly firstRun?: StepRun | undefined;
+    readonly lastRun?: StepRun | undefined;
+    /**
+     * retryCount > 0.
+     */
+    readonly flaky: boolean;
+}
+export interface StepRun {
+    readonly status: StepStatus;
+    readonly begin?: Snapshot | undefined;
+    readonly end?: Snapshot | undefined;
+    readonly duration?: number | undefined;
+    readonly error?: Error | undefined;
+}
+declare class askuiStep implements Step {
+    instruction: Instruction;
+    runs: Readonly<StepRun[]>;
+    constructor(instruction: Instruction);
+    get status(): StepStatus;
+    get begin(): Snapshot | undefined;
+    get end(): Snapshot | undefined;
+    get error(): Error | undefined;
+    get retries(): StepRun[];
+    get retryCount(): number;
+    get firstRun(): StepRun | undefined;
+    get lastRun(): StepRun | undefined;
+    get flaky(): boolean;
+    get duration(): number | undefined;
+    onBegin(snapshot: Snapshot): askuiStep;
+    onRetry(snapshot: Snapshot, error: Error): askuiStep;
+    onEnd(snapshot: Snapshot, error?: Error): askuiStep;
+    private determineLastRunStatus;
+}
+/**
+ * - `passed`: the step passed
+ * - `failed`: the step failed because of a failed (implicit/explicit) assertion, e.g., an element could not be found
+ * - `pending`: the step is waiting for a previous step to pass
+ * - `running`: the step is currently running (including retries)
+ * - `skipped`: the step was skipped, e.g., because a previous step failed or because workflow was skipped
+ * - `erroneous`: the step could not be run because of a runtime error, e.g., the user has no usage left, response of inference backend cannot be processed, e.g., because lib version is outdated, etc. (currently not supported, everything "failed")
+ */
+export declare type StepStatus = 'passed' | 'failed' | 'pending' | 'running' | 'erroneous';
+export declare type StepStatusEnd = 'passed' | 'failed' | 'erroneous';
+/**
+ * Can be used to report on a step run.
+ *
+ * The reporter is an interface (instead of a class) so that the it may be implemented by a class that already extends another class, e.g., the reporter of a test framework.
+ */
+export interface Reporter {
+    config?: ReporterConfig;
+    onStepBegin?(step: Step): Promise<void>;
+    onStepRetry?(step: Step): Promise<void>;
+    onStepEnd?(step: Step): Promise<void>;
+}
+export declare type SnapshotDetailLevel = 
+/**
+ * Details of snapshot, e.g., screenshot or detected elements, may or may not be available depending on if they are required by the step. There are not guarantees made.
+ */
+'required' | 
+/**
+ * Details are available when the step fails, e.g., for debugging. Includes everything of required.
+ */
+'onFailure' | 
+/**
+ * Details are available also when the command is started, e.g., for detecting why a certain element was interacted with. Includes everything of onFailure.
+ */
+'begin' | 
+/**
+ * Details are available always, e.g., before and after a step has been run no matter if it failed or not for debugging.
+ */
+'always';
+export interface ReporterConfig {
+    withScreenshots?: SnapshotDetailLevel;
+    withDetectedElements?: SnapshotDetailLevel;
+}
+export declare const DEFAULT_REPORTER: {
+    config: {
+        readonly withScreenshots: "onFailure";
+        readonly withDetectedElements: "onFailure";
+    };
+    onStepBegin: (_step: Step) => Promise<void>;
+    onStepRetry: (_step: Step) => Promise<void>;
+    onStepEnd: (_step: Step) => Promise<void>;
+};
+export declare class StepReporter {
+    private reporter;
+    currentStep?: askuiStep | undefined;
+    constructor(reporter: Required<Reporter> & {
+        config: Required<ReporterConfig>;
+    });
+    get config(): Required<ReporterConfig>;
+    resetStep(instruction: Instruction): void;
+    onStepBegin(snapshot: Snapshot): Promise<void>;
+    onStepRetry(snapshot: Snapshot, error: Error): Promise<void>;
+    onStepEnd(snapshot: Snapshot, error?: Error): Promise<void>;
+}
+export {};

package/dist/esm/execution/reporter.js

@@ -0,0 +1,142 @@
+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());
+    });
+};
+// retries could be modeled as totally new steps only that we set the retry no at the beginning, it is undefined if there is no retry or 0 --> user could filter out the retries for the report and has to get the last retry to find out when the step actually ended and the snapshot at that point in time
+// Where do I save the error of the first step, what state does the first step have?
+// We could point back from retry to original step, but then we have to save the original step in the retry step, which is not nice
+// retry should be handled like completely new step but the state of the whole state is not failed --> if a passed step can have an error, then this is fine 
+// how do we determine if it is erroneous or failed?
+class askuiStep {
+    constructor(instruction) {
+        this.instruction = instruction;
+        this.runs = [];
+    }
+    get status() {
+        var _a, _b;
+        return (_b = (_a = this.lastRun) === null || _a === void 0 ? void 0 : _a.status) !== null && _b !== void 0 ? _b : 'pending';
+    }
+    get begin() {
+        var _a;
+        return (_a = this.firstRun) === null || _a === void 0 ? void 0 : _a.begin;
+    }
+    get end() {
+        var _a;
+        return (_a = this.lastRun) === null || _a === void 0 ? void 0 : _a.end;
+    }
+    get error() {
+        var _a;
+        return (_a = this.lastRun) === null || _a === void 0 ? void 0 : _a.error;
+    }
+    get retries() {
+        var _a, _b;
+        return (_b = (_a = this.runs) === null || _a === void 0 ? void 0 : _a.slice(1)) !== null && _b !== void 0 ? _b : [];
+    }
+    get retryCount() {
+        var _a, _b;
+        return (_b = (_a = this.retries) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+    }
+    get firstRun() {
+        var _a;
+        return (_a = this.runs) === null || _a === void 0 ? void 0 : _a[0];
+    }
+    get lastRun() {
+        var _a;
+        return (_a = this.runs) === null || _a === void 0 ? void 0 : _a[this.runs.length - 1];
+    }
+    get flaky() {
+        return this.retryCount > 0;
+    }
+    get duration() {
+        if (this.begin !== undefined && this.end !== undefined) {
+            return this.end.createdAt.getTime() - this.begin.createdAt.getTime();
+        }
+        return undefined;
+    }
+    onBegin(snapshot) {
+        this.runs = [...this.runs, {
+                status: 'running',
+                begin: snapshot,
+            }];
+        return this;
+    }
+    onRetry(snapshot, error) {
+        this.onEnd(snapshot, error);
+        this.onBegin(snapshot);
+        return this;
+    }
+    onEnd(snapshot, error) {
+        this.runs = [...this.runs.slice(0, -1), Object.assign(Object.assign({}, this.lastRun), { status: this.determineLastRunStatus(error), end: snapshot, error, duration: snapshot.createdAt.getTime() - this.lastRun.begin.createdAt.getTime() })];
+        return this;
+    }
+    determineLastRunStatus(error) {
+        if (error !== undefined) {
+            return 'failed';
+        }
+        return 'passed';
+    }
+}
+export const DEFAULT_REPORTER = {
+    config: {
+        withScreenshots: 'onFailure',
+        withDetectedElements: 'onFailure',
+    },
+    onStepBegin: (_step) => {
+        return Promise.resolve();
+    },
+    onStepRetry: (_step) => {
+        return Promise.resolve();
+    },
+    onStepEnd: (_step) => {
+        return Promise.resolve();
+    },
+};
+export class StepReporter {
+    constructor(reporter) {
+        this.reporter = reporter;
+    }
+    get config() {
+        return this.reporter.config;
+    }
+    resetStep(instruction) {
+        this.currentStep = new askuiStep(instruction);
+    }
+    onStepBegin(snapshot) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.currentStep === undefined)
+                throw new Error('Cannot begin step if step is undefined.');
+            if (this.currentStep.status !== 'pending')
+                throw new Error('Cannot begin step that is not pending.');
+            this.currentStep.onBegin(snapshot);
+            yield ((_b = (_a = this.reporter).onStepBegin) === null || _b === void 0 ? void 0 : _b.call(_a, this.currentStep));
+        });
+    }
+    onStepRetry(snapshot, error) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.currentStep === undefined)
+                throw new Error('Cannot retry step if step is undefined.');
+            if (this.currentStep.status !== 'running')
+                throw new Error('Cannot retry step that has not been running.');
+            this.currentStep.onRetry(snapshot, error);
+            yield ((_b = (_a = this.reporter).onStepRetry) === null || _b === void 0 ? void 0 : _b.call(_a, this.currentStep));
+        });
+    }
+    onStepEnd(snapshot, error) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.currentStep === undefined)
+                throw new Error('Cannot end step if step is undefined.');
+            if (this.currentStep.status !== 'running')
+                throw new Error('Cannot end step that has not been running.');
+            this.currentStep.onEnd(snapshot, error);
+            yield ((_b = (_a = this.reporter).onStepEnd) === null || _b === void 0 ? void 0 : _b.call(_a, this.currentStep));
+        });
+    }
+}

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

@@ -1,2 +1,3 @@
 export declare class UiControlClientError extends Error {
+    constructor(message: string);
 }

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

@@ -1,2 +1,6 @@
 export class UiControlClientError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'UiControlClientError';
+    }
 }

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

@@ -89,7 +89,7 @@ export class UiControlClient extends ApiCommands {
     }
     annotate(annotationRequest = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            const annotation = yield this.executionRuntime.annotateImage(annotationRequest.imagePath, annotationRequest.customElements);
+            const annotation = yield this.executionRuntime.annotateImage(annotationRequest.imagePath, annotationRequest.customElements, annotationRequest.elements);
             AnnotationWriter.write(annotation.toHtml(), annotationRequest.outputPath, annotationRequest.fileNamePrefix);
             return annotation;
         });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "askui",
-    "version": "0.11.3",
+    "version": "0.11.4",
     "license": "MIT",
     "author": "askui GmbH <info@askui.com> (http://www.askui.com/)",
     "description": "Reliable, automated end-to-end-testing that depends on what is shown on your screen instead of the technology you are running on",

package/dist/cjs/core/ui-control-commands/action-class-tdk-v1.d.ts

@@ -1,19 +0,0 @@
-export declare enum ActionClassIdTdkV1 {
-    ActionClassID_Undefined = "ActionClassID_Undefined",
-    ActionClassID_Wait = "ActionClassID_Wait",
-    ActionClassID_MouseButton_Press = "ActionClassID_MouseButton_Press",
-    ActionClassID_MouseButton_Release = "ActionClassID_MouseButton_Release",
-    ActionClassID_MouseButton_PressAndRelease = "ActionClassID_MouseButton_PressAndRelease",
-    ActionClassID_MouseWheelScroll = "ActionClassID_MouseWheelScroll",
-    ActionClassID_MouseMove = "ActionClassID_MouseMove",
-    ActionClassID_MouseMove_Delta = "ActionClassID_MouseMove_Delta",
-    ActionClassID_KeyboardKey_Press = "ActionClassID_KeyboardKey_Press",
-    ActionClassID_KeyboardKey_Release = "ActionClassID_KeyboardKey_Release",
-    ActionClassID_KeyboardKey_PressAndRelease = "ActionClassID_KeyboardKey_PressAndRelease",
-    ActionClassID_KeyboardKeys_Press = "ActionClassID_KeyboardKeys_Press",
-    ActionClassID_KeyboardKeys_Release = "ActionClassID_KeyboardKeys_Release",
-    ActionClassID_KeyboardKeys_PressAndRelease = "ActionClassID_KeyboardKeys_PressAndRelease",
-    ActionClassID_KeyboardType_Text = "ActionClassID_KeyboardType_Text",
-    ActionClassID_KeyboardType_UnicodeText = "ActionClassID_KeyboardType_UnicodeText",
-    ActionClassID_RunCommand = "ActionClassID_RunCommand"
-}

package/dist/cjs/core/ui-control-commands/action-class-tdk-v1.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ActionClassIdTdkV1 = void 0;
-var ActionClassIdTdkV1;
-(function (ActionClassIdTdkV1) {
-    ActionClassIdTdkV1["ActionClassID_Undefined"] = "ActionClassID_Undefined";
-    ActionClassIdTdkV1["ActionClassID_Wait"] = "ActionClassID_Wait";
-    ActionClassIdTdkV1["ActionClassID_MouseButton_Press"] = "ActionClassID_MouseButton_Press";
-    ActionClassIdTdkV1["ActionClassID_MouseButton_Release"] = "ActionClassID_MouseButton_Release";
-    ActionClassIdTdkV1["ActionClassID_MouseButton_PressAndRelease"] = "ActionClassID_MouseButton_PressAndRelease";
-    ActionClassIdTdkV1["ActionClassID_MouseWheelScroll"] = "ActionClassID_MouseWheelScroll";
-    ActionClassIdTdkV1["ActionClassID_MouseMove"] = "ActionClassID_MouseMove";
-    ActionClassIdTdkV1["ActionClassID_MouseMove_Delta"] = "ActionClassID_MouseMove_Delta";
-    ActionClassIdTdkV1["ActionClassID_KeyboardKey_Press"] = "ActionClassID_KeyboardKey_Press";
-    ActionClassIdTdkV1["ActionClassID_KeyboardKey_Release"] = "ActionClassID_KeyboardKey_Release";
-    ActionClassIdTdkV1["ActionClassID_KeyboardKey_PressAndRelease"] = "ActionClassID_KeyboardKey_PressAndRelease";
-    ActionClassIdTdkV1["ActionClassID_KeyboardKeys_Press"] = "ActionClassID_KeyboardKeys_Press";
-    ActionClassIdTdkV1["ActionClassID_KeyboardKeys_Release"] = "ActionClassID_KeyboardKeys_Release";
-    ActionClassIdTdkV1["ActionClassID_KeyboardKeys_PressAndRelease"] = "ActionClassID_KeyboardKeys_PressAndRelease";
-    ActionClassIdTdkV1["ActionClassID_KeyboardType_Text"] = "ActionClassID_KeyboardType_Text";
-    ActionClassIdTdkV1["ActionClassID_KeyboardType_UnicodeText"] = "ActionClassID_KeyboardType_UnicodeText";
-    ActionClassIdTdkV1["ActionClassID_RunCommand"] = "ActionClassID_RunCommand";
-})(ActionClassIdTdkV1 = exports.ActionClassIdTdkV1 || (exports.ActionClassIdTdkV1 = {}));

package/dist/cjs/core/ui-control-commands/action-tdk-v1.d.ts

@@ -1,10 +0,0 @@
-import { ActionParameters } from '../../proto/Askui/API/TDKv1/ActionParameters';
-import { ActionClassIdTdkV1 } from './action-class-tdk-v1';
-import { Action } from './action';
-export declare class ActionTdkV1 {
-    actionClassID: ActionClassIdTdkV1;
-    actionParameters: ActionParameters;
-    constructor(actionClassID: ActionClassIdTdkV1, actionParameters: ActionParameters);
-    static fromJson(json: unknown, _resizeRatio?: number): ActionTdkV1;
-    static fromAction(action: Action, _resizeRatio?: number): ActionTdkV1;
-}