ff-automationv2 2.2.29 → 2.2.31

package/dist/fireflinkData/fireflinkLocators/utils/androidSelector.js

@@ -1,31 +1,57 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateAndroidLocators = void 0;
+exports.generateAiAndroidLocators = void 0;
 const xpathHelpers_js_1 = require("./xpathHelpers.js");
-const addLocator = (locators, key, attribute, value, element, docmt, isTarget) => {
-    const xpath = (0, xpathHelpers_js_1.getPropertyXPath)(element, docmt, attribute, value, false, isTarget, 'android');
+const addAiLocator = (locators, key, attribute, value, element, docmt, isTarget) => {
+    const xpath = (0, xpathHelpers_js_1.getAiPropertyXPath)(element, docmt, attribute, value, isTarget, 'android');
     if (xpath &&
-        (0, xpathHelpers_js_1.getCountOfXPath)(xpath, element, docmt) === 1) {
+        (0, xpathHelpers_js_1.getAiCountOfXPath)(xpath, element, docmt) === 1) {
         locators.push({
             key,
             value: xpath
         });
     }
 };
-const generateAndroidLocators = (element, docmt, isTarget) => {
+const generateAiAndroidLocators = (element, docmt, isTarget) => {
     const locators = [];
     const resourceId = element.getAttribute("resource-id");
     const contentDesc = element.getAttribute("content-desc");
     const text = element.getAttribute("text");
     if (resourceId) {
-        addLocator(locators, "androidResourceID", "@resource-id", resourceId, element, docmt, isTarget);
+        addAiLocator(locators, "androidResourceID", "@resource-id", resourceId, element, docmt, isTarget);
     }
     if (contentDesc) {
-        addLocator(locators, "androidAccessibilityID", "@content-desc", contentDesc, element, docmt, isTarget);
+        addAiLocator(locators, "androidAccessibilityID", "@content-desc", contentDesc, element, docmt, isTarget);
     }
     if (text) {
-        addLocator(locators, "androidText", "@text", text, element, docmt, isTarget);
+        addAiLocator(locators, "androidText", "@text", text, element, docmt, isTarget);
+    }
+    if (locators.length === 0) {
+        const relativeXpath = (0, xpathHelpers_js_1.getAIRelativeXPath)(element, docmt, isTarget, Array.from(element.attributes), "android");
+        if (relativeXpath && (0, xpathHelpers_js_1.getAiCountOfXPath)(relativeXpath, element, docmt) === 1) {
+            locators.push({
+                key: "Relative xpath",
+                value: relativeXpath
+            });
+        }
+    }
+    if (locators.length === 0) {
+        const absoluteXpath = (0, xpathHelpers_js_1.getAiAbsoluteXPath)(element, docmt);
+        if (absoluteXpath) {
+            if (absoluteXpath.startsWith('/hierarchy')) {
+                locators.push({
+                    key: "absoluteXPath",
+                    value: absoluteXpath
+                });
+            }
+            else {
+                locators.push({
+                    key: "absoluteXPath",
+                    value: `/hierarchy${absoluteXpath}`
+                });
+            }
+        }
     }
     return locators;
 };
-exports.generateAndroidLocators = generateAndroidLocators;
+exports.generateAiAndroidLocators = generateAiAndroidLocators;

package/dist/fireflinkData/fireflinkLocators/utils/cssSelector.d.ts

@@ -1,19 +1,19 @@
 import { SelectorMode } from "../types/locator.js";
-export declare const parseCssSelectors: (el: Element, mode?: SelectorMode) => {
+export declare const parseAiCssSelectors: (el: Element, mode?: SelectorMode) => {
     key: string;
     value: string;
 }[];
-export declare const getIdCssPath: (el: HTMLElement | Element) => string | undefined;
-export declare const getAttributeCssPath: (el: Element) => string | undefined;
-export declare const getClassCssPath: (el: HTMLElement | Element) => string | undefined;
-export declare const getAbsoluteCssPath: (el: Element) => string | undefined;
+export declare const getIdAiCssPath: (el: HTMLElement | Element) => string | undefined;
+export declare const getAiAttributeCssPath: (el: Element) => string | undefined;
+export declare const getAiClassCssPath: (el: HTMLElement | Element) => string | undefined;
+export declare const getAiAbsoluteCssPath: (el: Element) => string | undefined;
 export declare const cssSelectors: {
-    parseCssSelectors: (el: Element, mode?: SelectorMode) => {
+    parseAiCssSelectors: (el: Element, mode?: SelectorMode) => {
         key: string;
         value: string;
     }[];
-    getIdCssPath: (el: HTMLElement | Element) => string | undefined;
-    getAttributeCssPath: (el: Element) => string | undefined;
-    getClassCssPath: (el: HTMLElement | Element) => string | undefined;
-    getAbsoluteCssPath: (el: Element) => string | undefined;
+    getIdAiCssPath: (el: HTMLElement | Element) => string | undefined;
+    getAiAttributeCssPath: (el: Element) => string | undefined;
+    getAiClassCssPath: (el: HTMLElement | Element) => string | undefined;
+    getAiAbsoluteCssPath: (el: Element) => string | undefined;
 };

package/dist/fireflinkData/fireflinkLocators/utils/cssSelector.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.cssSelectors = exports.getAbsoluteCssPath = exports.getClassCssPath = exports.getAttributeCssPath = exports.getIdCssPath = exports.parseCssSelectors = void 0;
+exports.cssSelectors = exports.getAiAbsoluteCssPath = exports.getAiClassCssPath = exports.getAiAttributeCssPath = exports.getIdAiCssPath = exports.parseAiCssSelectors = void 0;
 const logData_js_1 = require("../../../utils/logger/logData.js");
 const xpathHelpers_js_1 = require("./xpathHelpers.js");
-const escapeCssAttributeValue = (value) => {
+const escapeAiCssAttributeValue = (value) => {
     return String(value).replace(/\\/g, "\\\\").replace(/"/g, '\\"');
 };
-const isCssSelectorUnique = (selector, el, root) => {
+const isAiCssSelectorUnique = (selector, el, root) => {
     try {
         const matches = root.querySelectorAll(selector);
         return matches.length === 1 && matches[0] === el;
@@ -15,21 +15,21 @@ const isCssSelectorUnique = (selector, el, root) => {
         return false;
     }
 };
-const parseCssSelectors = (el, mode = "single") => {
+const parseAiCssSelectors = (el, mode = "single") => {
     const selectors = [];
     const root = el.getRootNode();
     try {
-        const idPath = (0, exports.getIdCssPath)(el);
-        if (idPath && isCssSelectorUnique(idPath, el, root)) {
+        const idPath = (0, exports.getIdAiCssPath)(el);
+        if (idPath && isAiCssSelectorUnique(idPath, el, root)) {
             selectors.push({ key: "cssSelector by id", value: idPath });
             if (mode === "single")
                 return selectors;
         }
-        const classPath = (0, exports.getClassCssPath)(el);
-        if (classPath && isCssSelectorUnique(classPath, el, root)) {
+        const classPath = (0, exports.getAiClassCssPath)(el);
+        if (classPath && isAiCssSelectorUnique(classPath, el, root)) {
             selectors.push({ key: "cssSelector by class", value: classPath });
         }
-        const namePath = (0, exports.getAttributeCssPath)(el);
+        const namePath = (0, exports.getAiAttributeCssPath)(el);
         if (namePath) {
             selectors.push({ key: "cssSelector by name", value: namePath });
         }
@@ -39,27 +39,27 @@ const parseCssSelectors = (el, mode = "single") => {
     }
     return selectors;
 };
-exports.parseCssSelectors = parseCssSelectors;
-function cssEscape(value) {
+exports.parseAiCssSelectors = parseAiCssSelectors;
+function cssAiEscape(value) {
     return value.replace(/([ !"#$%&'()*+,./:;<=>?@[\\\]^`{|}~])/g, "\\$1");
 }
-const getIdCssPath = (el) => {
-    const view = el.ownerDocument?.defaultView;
-    if (!view || !(el instanceof view.Element))
+const getIdAiCssPath = (el) => {
+    if (!el || el.nodeType !== 1)
         return;
     const tagName = el.tagName.toLowerCase();
     if (tagName.includes("style") || tagName.includes("script"))
         return;
     const path = [];
-    while (el?.nodeType === 1) {
-        let selector = el.nodeName?.toLowerCase();
-        if (el.id && !(0, xpathHelpers_js_1.isNumberExist)(el.id)) {
-            selector += `#${cssEscape(el.id)}`;
+    let currentEl = el;
+    while (currentEl && currentEl.nodeType === 1) {
+        let selector = currentEl.nodeName?.toLowerCase();
+        if (currentEl.id && !(0, xpathHelpers_js_1.isAiNumberExist)(currentEl.id)) {
+            selector += `#${cssAiEscape(currentEl.id)}`;
             path.unshift(selector);
             break;
         }
         else {
-            let sib = el;
+            let sib = currentEl;
             let nth = 1;
             if (sib.previousElementSibling) {
                 while ((sib = sib.previousElementSibling)) {
@@ -70,17 +70,17 @@ const getIdCssPath = (el) => {
             if (nth !== 1) {
                 selector += `:nth-of-type(${nth})`;
             }
-            const parent = el.parentElement;
+            const parent = currentEl.parentElement;
             if (nth === 1 && parent?.childElementCount > 1) {
                 selector += `:nth-child(${nth})`;
             }
         }
         path.unshift(selector);
-        el = el.parentElement;
+        currentEl = currentEl.parentElement;
     }
     return path.join(" > ");
 };
-exports.getIdCssPath = getIdCssPath;
+exports.getIdAiCssPath = getIdAiCssPath;
 const EXCLUDED_ATTRS = new Set([
     "id",
     "class",
@@ -89,55 +89,54 @@ const EXCLUDED_ATTRS = new Set([
     "ff-inspecter",
     "ff-xpath"
 ]);
-function getAttributeSelectors(el) {
+function getAiAttributeSelectors(el) {
     return Array.from(el.attributes)
         .filter((attr) => !EXCLUDED_ATTRS.has(attr?.name?.toLowerCase()) &&
         attr.value &&
-        !(0, xpathHelpers_js_1.isNumberExist)(attr.value))
-        .map((attr) => `[${attr.name}="${escapeCssAttributeValue(attr.value)}"]`);
+        !(0, xpathHelpers_js_1.isAiNumberExist)(attr.value))
+        .map((attr) => `[${attr.name}="${escapeAiCssAttributeValue(attr.value)}"]`);
 }
-const getAttributeCssPath = (el) => {
-    const view = el.ownerDocument?.defaultView;
-    if (!view || !(el instanceof view.Element))
+const getAiAttributeCssPath = (el) => {
+    if (!el || el.nodeType !== 1)
         return;
     const root = el.getRootNode();
     const tag = el.tagName.toLowerCase();
     if (tag === "style" || tag === "script")
         return;
-    const attrSelectors = getAttributeSelectors(el);
+    const attrSelectors = getAiAttributeSelectors(el);
     for (const attrSelector of attrSelectors) {
         const candidate = `${tag}${attrSelector}`;
-        if (isCssSelectorUnique(candidate, el, root)) {
+        if (isAiCssSelectorUnique(candidate, el, root)) {
             return candidate;
         }
     }
     return;
 };
-exports.getAttributeCssPath = getAttributeCssPath;
-const getClassCssPath = (el) => {
-    const view = el.ownerDocument?.defaultView;
-    if (!view || !(el instanceof view.Element))
+exports.getAiAttributeCssPath = getAiAttributeCssPath;
+const getAiClassCssPath = (el) => {
+    if (!el || el.nodeType !== 1)
         return;
     const tagName = el.tagName.toLowerCase();
     if (tagName.includes("style") || tagName.includes("script"))
         return;
     const path = [];
-    const NodeRef = el.ownerDocument.defaultView.Node;
-    while (el?.nodeType === NodeRef.ELEMENT_NODE) {
-        let selector = el.nodeName?.toLowerCase();
-        if (typeof el.className === "string" &&
-            el.className &&
-            !(0, xpathHelpers_js_1.isNumberExist)(el.className)) {
-            el.classList.remove("marked-element-temp");
-            el.classList.remove("removePointers");
-            if (el.className) {
-                selector += `.${el.className.trim().replace(/\s+/g, ".")}`;
+    let currentEl = el;
+    while (currentEl && currentEl.nodeType === 1) {
+        let selector = currentEl.nodeName?.toLowerCase();
+        const className = currentEl.getAttribute("class") || currentEl.className;
+        if (typeof className === "string" &&
+            className &&
+            !(0, xpathHelpers_js_1.isAiNumberExist)(className)) {
+            currentEl.classList?.remove("marked-element-temp");
+            currentEl.classList?.remove("removePointers");
+            if (className) {
+                selector += `.${className.trim().replace(/\s+/g, ".")}`;
                 path.unshift(selector);
                 break;
             }
         }
         else {
-            let sib = el;
+            let sib = currentEl;
             let nth = 1;
             if (sib.previousElementSibling) {
                 while ((sib = sib.previousElementSibling)) {
@@ -148,24 +147,22 @@ const getClassCssPath = (el) => {
             if (nth !== 1) {
                 selector += `:nth-of-type(${nth})`;
             }
-            const parent = el.parentElement;
+            const parent = currentEl.parentElement;
             if (nth === 1 && parent?.childElementCount > 1) {
                 selector += `:nth-child(${nth})`;
             }
         }
         path.unshift(selector);
-        el = el.parentElement;
+        currentEl = currentEl.parentElement;
     }
     return path.join(" > ");
 };
-exports.getClassCssPath = getClassCssPath;
-const getAbsoluteCssPath = (el) => {
-    const view = el.ownerDocument?.defaultView;
-    if (!view || !(el instanceof view.Element))
+exports.getAiClassCssPath = getAiClassCssPath;
+const getAiAbsoluteCssPath = (el) => {
+    if (!el || el.nodeType !== 1)
         return;
     const path = [];
-    const NodeRef = el.ownerDocument.defaultView.Node;
-    while (el && el.nodeType === NodeRef.ELEMENT_NODE) {
+    while (el && el.nodeType === 1) {
         const tagName = el.tagName.toLowerCase();
         if (tagName === "style" || tagName === "script")
             return;
@@ -182,11 +179,11 @@ const getAbsoluteCssPath = (el) => {
     }
     return path.join(" > ");
 };
-exports.getAbsoluteCssPath = getAbsoluteCssPath;
+exports.getAiAbsoluteCssPath = getAiAbsoluteCssPath;
 exports.cssSelectors = {
-    parseCssSelectors: exports.parseCssSelectors,
-    getIdCssPath: exports.getIdCssPath,
-    getAttributeCssPath: exports.getAttributeCssPath,
-    getClassCssPath: exports.getClassCssPath,
-    getAbsoluteCssPath: exports.getAbsoluteCssPath
+    parseAiCssSelectors: exports.parseAiCssSelectors,
+    getIdAiCssPath: exports.getIdAiCssPath,
+    getAiAttributeCssPath: exports.getAiAttributeCssPath,
+    getAiClassCssPath: exports.getAiClassCssPath,
+    getAiAbsoluteCssPath: exports.getAiAbsoluteCssPath
 };

package/dist/fireflinkData/fireflinkLocators/utils/iosSelector.d.ts

@@ -1,2 +1,2 @@
 import { XPathEntry } from "../types/locator.js";
-export declare const generateIOSLocators: (element: HTMLElement | Element, docmt: Document, isTarget: boolean) => XPathEntry[];
+export declare const generateAiIOSLocators: (element: HTMLElement | Element, docmt: Document, isTarget: boolean) => XPathEntry[];

package/dist/fireflinkData/fireflinkLocators/utils/iosSelector.js

@@ -1,59 +1,82 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateIOSLocators = void 0;
+exports.generateAiIOSLocators = void 0;
 const xpathHelpers_js_1 = require("./xpathHelpers.js");
 const logData_js_1 = require("../../../utils/logger/logData.js");
-const addLocator = (locators, key, attribute, value, element, docmt, isTarget) => {
-    const xpath = (0, xpathHelpers_js_1.getPropertyXPath)(element, docmt, attribute, value, false, isTarget, 'ios');
+const addAiLocator = (locators, key, attribute, value, element, docmt, isTarget) => {
+    const xpath = (0, xpathHelpers_js_1.getAiPropertyXPath)(element, docmt, attribute, value, isTarget, 'ios');
     if (xpath &&
-        (0, xpathHelpers_js_1.getCountOfXPath)(xpath, element, docmt) === 1) {
+        (0, xpathHelpers_js_1.getAiCountOfXPath)(xpath, element, docmt) === 1) {
         locators.push({
             key,
             value: xpath
         });
     }
 };
-const generateIOSLocators = (element, docmt, isTarget) => {
+const generateAiIOSLocators = (element, docmt, isTarget) => {
     const locators = [];
     const name = element.getAttribute("name");
     const label = element.getAttribute("label");
     const value = element.getAttribute("value");
-    const classChain = getOptimalClassChain(docmt, element, [
+    const classChain = getAiOptimalClassChain(docmt, element, [
         "label",
         "name",
         "value",
     ]);
-    const predicate = getOptimalPredicateString(docmt, element, [
+    const predicate = getAiOptimalPredicateString(docmt, element, [
         "label",
         "name",
         "value",
         "type",
     ]);
     if (name) {
-        addLocator(locators, "iosAccessibilityID", "@name", name, element, docmt, isTarget);
+        addAiLocator(locators, "iosAccessibilityID", "@name", name, element, docmt, isTarget);
     }
     if (label) {
-        addLocator(locators, "iosLabel", "@label", label, element, docmt, isTarget);
+        addAiLocator(locators, "iosLabel", "@label", label, element, docmt, isTarget);
     }
     if (value) {
-        addLocator(locators, "iosValue", "@value", value, element, docmt, isTarget);
+        addAiLocator(locators, "iosValue", "@value", value, element, docmt, isTarget);
     }
-    if (classChain) {
-        locators.push({
-            key: "iosClassChain",
-            value: `**${classChain}`,
-        });
+    if (locators.length === 0) {
+        let absoluteXpath = (0, xpathHelpers_js_1.getAiAbsoluteXPath)(element, docmt);
+        if (absoluteXpath) {
+            if (absoluteXpath.startsWith('/AppiumAUT')) {
+                absoluteXpath = absoluteXpath.substring('/AppiumAUT'.length);
+                if (!absoluteXpath.startsWith('/')) {
+                    absoluteXpath = `/${absoluteXpath}`;
+                }
+            }
+            else if (absoluteXpath.startsWith('AppiumAUT')) {
+                absoluteXpath = absoluteXpath.substring('AppiumAUT'.length);
+                if (!absoluteXpath.startsWith('/')) {
+                    absoluteXpath = `/${absoluteXpath}`;
+                }
+            }
+            locators.push({
+                key: "absoluteXPath",
+                value: absoluteXpath
+            });
+        }
     }
-    if (predicate) {
-        locators.push({
-            key: "iosPredicateString",
-            value: predicate,
-        });
+    if (locators.length === 0) {
+        if (classChain) {
+            locators.push({
+                key: "iosClassChain",
+                value: `**${classChain}`,
+            });
+        }
+        if (predicate) {
+            locators.push({
+                key: "iosPredicateString",
+                value: predicate,
+            });
+        }
     }
     return locators;
 };
-exports.generateIOSLocators = generateIOSLocators;
-function getOptimalClassChain(doc, domNode, uniqueAttributes) {
+exports.generateAiIOSLocators = generateAiIOSLocators;
+function getAiOptimalClassChain(doc, domNode, uniqueAttributes) {
     try {
         // BASE CASE #1: If this isn't an element, we're above the root, or this is `XCUIElementTypeApplication`,
         // which is not an official XCUITest element, return empty string
@@ -65,13 +88,13 @@ function getOptimalClassChain(doc, domNode, uniqueAttributes) {
         // BASE CASE #2: If this node has a unique class chain based on attributes then return it
         for (const attrName of uniqueAttributes) {
             const attrValue = domNode.getAttribute(attrName);
-            if (attrValue && !(0, xpathHelpers_js_1.isNumberExist)(attrValue)) {
+            if (attrValue && !(0, xpathHelpers_js_1.isAiNumberExist)(attrValue)) {
                 const xpathe = `//${domNode.tagName || '*'}[@${attrName}="${attrValue}"]`;
                 let classChain = `/${domNode.tagName || '*'}[\`${attrName} == "${attrValue}"\`]`;
                 let othersWithAttr;
                 // If the XPath does not parse, move to the next unique attribute
                 try {
-                    othersWithAttr = (0, xpathHelpers_js_1.getCountOfXPath)(xpathe, domNode, doc);
+                    othersWithAttr = (0, xpathHelpers_js_1.getAiCountOfXPath)(xpathe, domNode, doc);
                 }
                 catch (ign) {
                     logData_js_1.logger.error(ign);
@@ -82,7 +105,7 @@ function getOptimalClassChain(doc, domNode, uniqueAttributes) {
                 }
                 // If the attribute isn't actually unique, get it's index too
                 if (othersWithAttr > 1) {
-                    const index = (0, xpathHelpers_js_1.findXpathWithIndex)(xpathe, domNode, doc, 0);
+                    const index = (0, xpathHelpers_js_1.findAiXpathWithIndex)(xpathe, domNode, doc, 0);
                     if (index) {
                         classChain = `${classChain}[${index}]`;
                         return classChain;
@@ -105,7 +128,8 @@ function getOptimalClassChain(doc, domNode, uniqueAttributes) {
             }
         }
         // Make a recursive call to this nodes parents and prepend it to this xpath
-        return (getOptimalClassChain(doc, domNode.parentElement, uniqueAttributes) +
+        const parent = domNode.parentElement || domNode.parentNode;
+        return (getAiOptimalClassChain(doc, parent, uniqueAttributes) +
             classChain);
     }
     catch (error) {
@@ -114,7 +138,7 @@ function getOptimalClassChain(doc, domNode, uniqueAttributes) {
         return null;
     }
 }
-function getOptimalPredicateString(doc, domNode, uniqueAttributes) {
+function getAiOptimalPredicateString(doc, domNode, uniqueAttributes) {
     try {
         // BASE CASE #1: If this isn't an element, we're above the root, or this is `XCUIElementTypeApplication`,
         // which is not an official XCUITest element, return empty string
@@ -131,14 +155,14 @@ function getOptimalPredicateString(doc, domNode, uniqueAttributes) {
             if (!attrValue) {
                 continue;
             }
-            if (attrValue && !(0, xpathHelpers_js_1.isNumberExist)(attrValue)) {
+            if (attrValue && !(0, xpathHelpers_js_1.isAiNumberExist)(attrValue)) {
                 xpathAttributes.push(`@${attrName}="${attrValue}"`);
                 const xpathe = `//*[${xpathAttributes.join(' and ')}]`;
                 predicateString.push(`${attrName} == "${attrValue}"`);
                 let othersWithAttr;
                 // If the XPath does not parse, move to the next unique attribute
                 try {
-                    othersWithAttr = (0, xpathHelpers_js_1.getCountOfXPath)(xpathe, domNode, doc);
+                    othersWithAttr = (0, xpathHelpers_js_1.getAiCountOfXPath)(xpathe, domNode, doc);
                 }
                 catch (ign) {
                     logData_js_1.logger.error(ign);

package/dist/fireflinkData/fireflinkLocators/utils/referenceXpath.d.ts

@@ -1,8 +1,8 @@
-export declare const findRelativeXpath: (element1: Element, element2: Element, docmt: Document, xpaths1: any[], xpaths2: any[], isIndex: boolean, multiElementReferenceMode?: boolean, allowedRelations?: string[] | null) => any[];
-export declare const getSmartRelations: (element1: HTMLElement | Element, element2: HTMLElement | Element) => string[];
+export declare const findAiRelativeXpath: (element1: Element, element2: Element, docmt: Document, xpaths1: any[], xpaths2: any[], isIndex: boolean, multiElementReferenceMode?: boolean, allowedRelations?: string[] | null) => any[];
+export declare const getAiSmartRelations: (element1: HTMLElement | Element, element2: HTMLElement | Element) => string[];
 declare const referenceXpath: {
-    findRelativeXpath: (element1: Element, element2: Element, docmt: Document, xpaths1: any[], xpaths2: any[], isIndex: boolean, multiElementReferenceMode?: boolean, allowedRelations?: string[] | null) => any[];
-    getDescendantXpath: (refExpectElement: Array<HTMLElement | Element>, docmt: Document, xpaths1: {
+    findAiRelativeXpath: (element1: Element, element2: Element, docmt: Document, xpaths1: any[], xpaths2: any[], isIndex: boolean, multiElementReferenceMode?: boolean, allowedRelations?: string[] | null) => any[];
+    getAiDescendantXpath: (refExpectElement: Array<HTMLElement | Element>, docmt: Document, xpaths1: {
         key: string;
         value: string;
     }[], xpaths2: {
@@ -12,7 +12,7 @@ declare const referenceXpath: {
         key: string;
         value: string;
     }[] | undefined;
-    getAncestorBridgeXpath: (element1: HTMLElement | Element, element2: HTMLElement | Element, relation: "ancestor" | "ancestor-or-self", xpaths1: {
+    getAiAncestorBridgeXpath: (element1: HTMLElement | Element, element2: HTMLElement | Element, relation: "ancestor" | "ancestor-or-self", xpaths1: {
         key: string;
         value: string;
     }[], xpaths2: {
@@ -22,14 +22,14 @@ declare const referenceXpath: {
         key: string;
         value: string;
     }[];
-    getXpathRelationExpression: (element1: HTMLElement | Element, element2: HTMLElement | Element, relation: string, xpath1: any[], xpath2: any[], isIndex: boolean, multiElementReferenceMode: boolean) => {
+    getAiXpathRelationExpression: (element1: HTMLElement | Element, element2: HTMLElement | Element, relation: string, xpath1: any[], xpath2: any[], isIndex: boolean, multiElementReferenceMode: boolean) => {
         key: string;
         value: any;
     }[];
-    getTraverseXpathExpression: (xpathe1: string, absoluteXpathElements: string[], element2: HTMLElement | Element, refExpectElement: Array<HTMLElement | Element>, docmt: Node, relation: string, isIndex: boolean, multiElementReferenceMode: boolean) => {
+    getAiTraverseXpathExpression: (xpathe1: string, absoluteXpathElements: string[], element2: HTMLElement | Element, refExpectElement: Array<HTMLElement | Element>, docmt: Node, relation: string, isIndex: boolean, multiElementReferenceMode: boolean) => {
         key: string;
         value: string;
     }[] | undefined;
-    getSmartRelations: (element1: HTMLElement | Element, element2: HTMLElement | Element) => string[];
+    getAiSmartRelations: (element1: HTMLElement | Element, element2: HTMLElement | Element) => string[];
 };
 export default referenceXpath;