@intuned/browser-dev 2.2.3-unify-sdks.20

package/dist/optimized-extractors/common/matching/types.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MatchSource = exports.MatchMode = void 0;
+let MatchSource = exports.MatchSource = function (MatchSource) {
+  MatchSource["ATTRIBUTE"] = "attribute";
+  MatchSource["TEXT_CONTENT"] = "text_content";
+  MatchSource["DIRECT_TEXT_NODE"] = "direct_text_node";
+  return MatchSource;
+}({});
+let MatchMode = exports.MatchMode = function (MatchMode) {
+  MatchMode["FULL"] = "full";
+  MatchMode["PARTIAL"] = "partial";
+  MatchMode["FUZZY"] = "fuzzy";
+  return MatchMode;
+}({});

package/dist/optimized-extractors/common/matching/utils.js

@@ -0,0 +1,184 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calculateMaxLDist = calculateMaxLDist;
+exports.findClosestMatch = findClosestMatch;
+exports.getElementXPath = getElementXPath;
+exports.hasNonFuzzyOrCloseFuzzyMatch = hasNonFuzzyOrCloseFuzzyMatch;
+exports.isFuzzMatch = isFuzzMatch;
+exports.isMatchExact = isMatchExact;
+exports.isPartOfString = isPartOfString;
+exports.normalizeSpacing = normalizeSpacing;
+exports.rankMatch = rankMatch;
+exports.removePunctuationAndSpaces = removePunctuationAndSpaces;
+exports.selectBestMatch = selectBestMatch;
+exports.traverseAndPrune = traverseAndPrune;
+var _types = require("./types");
+var _levenshteinSearch = require("../../../common/fuzzySearch/levenshtein-search");
+function findClosestMatch(searchTerm, content, maxLDist) {
+  const results = [];
+  for (const result of (0, _levenshteinSearch.fuzzySearch)(searchTerm, content, maxLDist)) {
+    results.push(result);
+  }
+  results.sort((a, b) => {
+    if (a.dist === b.dist) {
+      return b.end - b.start - (a.end - a.start);
+    }
+    return a.dist - b.dist;
+  });
+  return results[0];
+}
+function normalizeSpacing(text) {
+  if (!text) {
+    return "";
+  }
+  let normalized = text.replace(/\n/g, " ").replace(/\t/g, " ");
+  normalized = normalized.split(/\s+/).join(" ");
+  return normalized.trim();
+}
+function isMatchExact(data, value) {
+  if (!data || !value) {
+    return [false, null];
+  }
+  const normalizedData = normalizeSpacing(data);
+  const normalizedValue = normalizeSpacing(value);
+  return [normalizedData === normalizedValue, normalizedValue];
+}
+function calculateMaxLDist(value) {
+  const length = value.length;
+  const Pmax = 0.2;
+  const Pmin = 0.05;
+  const lengthAtPmax = 10;
+  let percentage;
+  if (length <= lengthAtPmax) {
+    percentage = Pmax;
+  } else {
+    const k = -Math.log(Pmin / Pmax) / (600 - lengthAtPmax);
+    percentage = Pmax * Math.exp(-k * (length - lengthAtPmax));
+  }
+  percentage = Math.max(Pmin, percentage);
+  return Math.max(1, Math.floor(length * percentage));
+}
+function isFuzzMatch(searchTerm, content) {
+  if (!searchTerm || !content) {
+    return {
+      found: false,
+      matchedValue: null,
+      distance: null,
+      matchedSourceValue: null
+    };
+  }
+  const maxLDist = calculateMaxLDist(searchTerm);
+  const normalizedSearchTerm = normalizeSpacing(searchTerm);
+  const normalizedContent = normalizeSpacing(content);
+  const match = findClosestMatch(normalizedSearchTerm.toLowerCase(), normalizedContent.toLowerCase(), maxLDist);
+  if (!match) {
+    return {
+      found: false,
+      matchedValue: null,
+      distance: null,
+      matchedSourceValue: null
+    };
+  }
+  return {
+    found: true,
+    matchedValue: normalizedContent.slice(match.start, match.end),
+    matchedSourceValue: normalizedContent,
+    distance: match.dist
+  };
+}
+function hasNonFuzzyOrCloseFuzzyMatch(matches) {
+  const hasNonFuzzyMatch = matches.some(match => match.match_mode !== _types.MatchMode.FUZZY);
+  const hasVeryCloseFuzzyMatch = matches.some(match => match.match_mode === _types.MatchMode.FUZZY && match.fuzzy_distance && match.fuzzy_distance < 5);
+  return hasNonFuzzyMatch || hasVeryCloseFuzzyMatch;
+}
+function selectBestMatch(original, matches) {
+  const exactMatches = matches.filter(match => match.matchText !== _types.MatchMode.FUZZY);
+  if (exactMatches.length > 0) {
+    const fullExactMatch = exactMatches.find(i => i.exact);
+    const bestMatch = fullExactMatch ?? exactMatches[0];
+    return {
+      matchText: bestMatch.matchText,
+      matchXpath: bestMatch.matchXpath,
+      matchType: bestMatch.matchType
+    };
+  }
+  const fuzzyMatches = matches.filter(match => match.isFuzzy).map(match => [match, rankMatch(original, match)]).filter(([_, rank]) => rank === "HIGH");
+  if (fuzzyMatches.length > 0) {
+    fuzzyMatches.sort((a, b) => a[0].fuzzyDistance - b[0].fuzzyDistance);
+    const bestMatch = fuzzyMatches[0][0];
+    return {
+      matchText: bestMatch.matchText,
+      matchXpath: bestMatch.matchXpath,
+      matchType: bestMatch.matchType
+    };
+  }
+  return null;
+}
+function getElementXPath(element) {
+  if (!element || !element.parentNode || element.nodeName === "#document") {
+    return null;
+  }
+  let siblingsCount = 1;
+  const parent = element.parentNode;
+  const nodeName = element.nodeName.toLowerCase();
+  const siblings = Array.from(parent.childNodes).filter(node => node.nodeType === 1);
+  for (const sibling of siblings) {
+    if (sibling === element) {
+      break;
+    }
+    if (sibling.nodeName.toLowerCase() === nodeName) {
+      siblingsCount++;
+    }
+  }
+  const parentXPath = getElementXPath(parent);
+  if (element.nodeName === "#text") {
+    return parentXPath;
+  }
+  return parentXPath ? `${parentXPath}/${nodeName}[${siblingsCount}]` : `${nodeName}[${siblingsCount}]`;
+}
+function traverseAndPrune(node, conditionFunc) {
+  const children = Array.from(node.children ?? []);
+  children.forEach(child => {
+    if (child.children) {
+      if (!conditionFunc(child)) {
+        traverseAndPrune(child, conditionFunc);
+      }
+    }
+  });
+}
+function isPartOfString(input, dom) {
+  if (!input || !dom) {
+    return [false, null, null];
+  }
+  const normalizedInput = normalizeSpacing(input);
+  const normalizedDom = normalizeSpacing(dom);
+  const matchIndex = normalizedDom.toLowerCase().indexOf(normalizedInput.toLowerCase());
+  const matchedText = matchIndex !== -1 ? normalizedDom.substring(matchIndex, matchIndex + normalizedInput.length) : null;
+  return [matchIndex !== -1, matchedText, normalizedDom];
+}
+function removePunctuationAndSpaces(s) {
+  return s.replace(/[^\w\s]|_/g, "").replace(/\s+/g, "");
+}
+function similarityRatio(s1, s2, distance) {
+  const maxLength = Math.max(s1.length, s2.length);
+  return 1 - distance / maxLength;
+}
+function rankMatch(original, match) {
+  if (!original || !match.matchText) {
+    return "LOW";
+  }
+  const normalizedOriginal = normalizeSpacing(original).toLowerCase();
+  const normalizedMatch = normalizeSpacing(match.matchText).toLowerCase();
+  const ratio = similarityRatio(original, match.matchText, match.fuzzyDistance);
+  const lenOriginal = normalizedOriginal.length;
+  if (lenOriginal > 20 && ratio > 0.85) {
+    return "HIGH";
+  }
+  if (removePunctuationAndSpaces(normalizedOriginal) === removePunctuationAndSpaces(normalizedMatch)) {
+    return "HIGH";
+  }
+  return "LOW";
+}

package/dist/optimized-extractors/common/utils.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cleanupAiResult = cleanupAiResult;
+exports.getRandomItems = getRandomItems;
+exports.getResultFromOutputSchema = getResultFromOutputSchema;
+exports.processInputSchema = processInputSchema;
+function getRandomItems(arr, numItems) {
+  const shuffled = arr.sort(() => 0.5 - Math.random());
+  return shuffled.slice(0, numItems);
+}
+function processInputSchema(originalJsonSchema, entityName) {
+  const internalSchema = structuredClone(originalJsonSchema);
+  delete internalSchema.description;
+  if (originalJsonSchema.type === "array") {
+    return {
+      type: "object",
+      properties: {
+        [`number_of_${entityName}`]: {
+          type: "number",
+          description: `The number of ${entityName} items in the text - not the overall total. Relay on the text to find this, if the number is not mentioned in the text, this should be null. For example, some lists say 'showing 5 our of 20 items' - 5 is the number of items in the list.`
+        },
+        [`${entityName}`]: internalSchema
+      },
+      required: [`number_of_${entityName}`, `${entityName}`]
+    };
+  }
+  return internalSchema;
+}
+function getResultFromOutputSchema(originalJsonSchema, entityName, parsedData) {
+  if (originalJsonSchema.type === "array") {
+    const items = parsedData[entityName] ?? [];
+    return items;
+  }
+  return parsedData;
+}
+function cleanUpAiReturnedString(str) {
+  return str.replaceAll(/&/g, "&");
+}
+function cleanupAiResult(obj) {
+  if (typeof obj === "string") {
+    return cleanUpAiReturnedString(obj);
+  }
+  if (typeof obj !== "object" || obj === null) {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(cleanupAiResult);
+  }
+  return Object.entries(obj).reduce((acc, [key, value]) => {
+    if (value !== null && value !== undefined && value !== "") {
+      acc[key] = cleanupAiResult(value);
+    }
+    return acc;
+  }, {});
+}

package/dist/optimized-extractors/export.d.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/dist/optimized-extractors/export.d.ts

@@ -0,0 +1,397 @@
+import { Locator, Page } from "playwright-core";
+import { BasicSchema } from "./types/jsonSchema";
+
+/**
+ * this strategy will use a screenshot of the page/locator with some processing to extract the needed data.
+ * should be used when the information you're trying to extract is not present in the dom as a text but can be identified visually.
+ * @interface
+ * @property model - the model to use in the extraction process.
+ * @property  type - the type of the strategy
+ */
+export interface ImageStrategy {
+  model:
+    | "claude-3-haiku"
+    | "claude-3-haiku-20240307"
+    | "claude-3.5-sonnet"
+    | "claude-3-5-sonnet-20240620"
+    | "claude-3-5-sonnet-20241022"
+    | "claude-opus-4"
+    | "claude-opus-4-20250514"
+    | "claude-sonnet-4"
+    | "claude-sonnet-4-20250514"
+    | "gpt4-turbo"
+    | "gpt-4-turbo-2024-04-09"
+    | "gpt-4o"
+    | "gpt-4o-2024-05-13"
+    | "gpt-4o-mini"
+    | "gpt-4o-mini-2024-07-18"
+    | "gemini-1.5-pro"
+    | "gemini-1.5-pro-002"
+    | "gemini-1.5-flash-8b"
+    | "gemini-1.5-flash-8b-002"
+    | "gemini-1.5-flash"
+    | "gemini-1.5-flash-002"
+    | "gemini-2.0-flash-exp";
+  type: "IMAGE";
+}
+/**
+ * this strategy will use the html of the page/locator to extract the needed data. we filter out some of the attributes to reduce context.
+ * the attributes included are only: `aria-label` `data-name` `name` `type` `placeholder` `value` `role` `title` `href` `id` `alt`,
+ *
+ * @interface
+ * @property model - the model to use in the extraction process
+ * @property  type - the type of the strategy
+ */
+export interface HtmlStrategy {
+  model:
+    | "claude-3-haiku"
+    | "claude-3-haiku-20240307"
+    | "claude-3-5-haiku"
+    | "claude-3-5-haiku-20241022"
+    | "claude-3.5-sonnet"
+    | "claude-3-5-sonnet-20240620"
+    | "claude-3-5-sonnet-20241022"
+    | "claude-opus-4"
+    | "claude-opus-4-20250514"
+    | "claude-sonnet-4"
+    | "claude-sonnet-4-20250514"
+    | "gpt4-turbo"
+    | "gpt-4-turbo-2024-04-09"
+    | "gpt3.5-turbo"
+    | "gpt-3.5-turbo-0125"
+    | "gpt-4o"
+    | "gpt-4o-2024-05-13"
+    | "gpt-4o-mini"
+    | "gpt-4o-mini-2024-07-18"
+    | "gemini-1.5-pro"
+    | "gemini-1.5-pro-002"
+    | "gemini-1.5-flash-8b"
+    | "gemini-1.5-flash-8b-002"
+    | "gemini-1.5-flash"
+    | "gemini-1.5-flash-002"
+    | "gemini-2.0-flash-exp";
+  type: "HTML";
+}
+/**
+ * Extracts an array of structured data from a web page in an optimized way, this function will use ai for the first n times, until it collects multiple examples
+ * then it will build reliable selectors in the background to make the process more efficient
+ *
+ * @param page - The Playwright Page object from which to extract the data.
+ * @param options.label - A label for this extraction process, used for billing and monitoring.
+ * @param options.itemEntityName - The name of the entity items being extracted, it must be between 1 and 50 characters long and can only contain letters, digits, periods, underscores, and hyphens.
+ * @param options.itemEntitySchema - The schema of the entity items being extracted.
+ * @param options.strategy - Optional. The strategy to use for extraction, if not provided, the html strategy with claude haiku will be used.
+ * @param options.prompt - Optional. A prompt to guide the extraction process.
+ * @param options.optionalPropertiesInvalidator - Optional. A function to invalidate optional properties.
+ * @param options.variantKey - Optional. A variant key for the extraction process, use this when the page has multiple variants/shapes.
+ * @param options.apiKey - Optional. An API key to use for the AI extraction. Extractions made with you API key will not be billed to your account.
+ * @returns A promise that resolves to a list of extracted data.
+ *
+ * @example
+ * ```typescript extractArrayFromPage
+ *  import { extractArrayFromPage } from "@intuned/sdk/optimized-extractors";
+ *
+ *  await page.goto("https://books.toscrape.com/")
+ *  const books = await extractArrayFromPage(page,
+ *    {
+ *      strategy: {
+ *        model: "gpt4-turbo",
+ *        type: "HTML"
+ *      },
+ *      itemEntityName: "book",
+ *      label: "books-extraction",
+ *      itemEntitySchema: {
+ *        type: "object",
+ *        required: ["name"],
+ *        properties: {
+ *          name: {
+ *            type: "string",
+ *            description: "book name",
+ *            primary: true
+ *          }
+ *        }
+ *      }
+ *    },
+ *  )
+ *
+ *  console.log(books)
+ *
+ *  // output:
+ *  // [
+ *  // ...
+ *  // { name: 'Olio' },
+ *  // { name: 'Mesaerion: The Best Science Fiction Stories 1800-1849' },
+ *  // { name: 'Libertarianism for Beginners' },
+ *  // { name: "It's Only the Himalayas" }
+ *  // ...
+ *  // ]
+ *
+ * ```
+ */
+export declare function extractArrayFromPage(
+  page: Page,
+  options: {
+    label: string;
+    itemEntityName: string;
+    itemEntitySchema: SimpleArrayItemSchema;
+    strategy?: ImageStrategy | HtmlStrategy;
+    prompt?: string;
+    optionalPropertiesInvalidator?: (
+      result: Record<string, string>[]
+    ) => string[];
+    variantKey?: string;
+    apiKey?: string;
+  }
+): Promise<Record<string, string>[]>;
+
+/**
+ * Extracts an array of structured data from a locator.
+ *
+ * @param locator - The Playwright Locator object from which to extract the data.
+ * @param options.label - A label for this extraction process, used for billing and monitoring.
+ * @param options.itemEntityName - The name of the entity items being extracted. it must be between 1 and 50 characters long and can only contain letters, digits, periods, underscores, and hyphens.
+ * @param options.itemEntitySchema - The schema of the entity items being extracted.
+ * @param options.strategy - Optional. The strategy to use for extraction, if not provided, the html strategy with claude haiku will be used.
+ * @param options.prompt - Optional. A prompt to guide the extraction process.
+ * @param options.optionalPropertiesInvalidator - Optional. A function to invalidate optional properties.
+ * @param options.variantKey - Optional. A variant key for the extraction process.
+ * @param options.apiKey - Optional. An API key to use for the AI extraction. Extractions made with you API key will not be billed to your account.
+ * @returns A promise that resolves to a list of extracted data.
+ *
+ * @example
+ * ```typescript extractArrayFromLocator
+ *  import { extractArrayFromLocator } from "@intuned/sdk/optimized-extractors";
+ *
+ *  await page.goto("https://books.toscrape.com/")
+ *  const books = await extractArrayFromLocator(page.locator("section"),
+ *    {
+ *      itemEntityName: "book",
+ *      label: "books-extraction",
+ *      itemEntitySchema: {
+ *        type: "object",
+ *        required: ["name"],
+ *        properties: {
+ *          name: {
+ *            type: "string",
+ *            description: "book name",
+ *            primary: true
+ *          }
+ *        }
+ *      }
+ *    },
+ *  )
+ *
+ *  console.log(books)
+ *
+ *  // output:
+ *  // [
+ *  // ...
+ *  // { name: 'Olio' },
+ *  // { name: 'Mesaerion: The Best Science Fiction Stories 1800-1849' },
+ *  // { name: 'Libertarianism for Beginners' },
+ *  // { name: "It's Only the Himalayas" }
+ *  // ...
+ *  // ]
+ *
+ * ```
+ */
+export declare function extractArrayFromLocator(
+  locator: Locator,
+  options: {
+    label: string;
+    itemEntityName: string;
+    itemEntitySchema: SimpleArrayItemSchema;
+    strategy?: ImageStrategy | HtmlStrategy;
+    prompt?: string;
+    optionalPropertiesInvalidator?: (
+      result: Record<string, string>[]
+    ) => string[];
+    variantKey?: string;
+    apiKey?: string;
+  }
+): Promise<Record<string, string>[]>;
+
+/**
+ * A simple object schema with string properties.
+ * @interface SimpleObjectStringSchema
+ * @extends BasicSchema
+ * @property type - The type of the schema, which is always "string".
+ */
+interface SimpleObjectStringSchema extends BasicSchema {
+  type: "string";
+}
+
+/**
+ * A simple array schema with string properties.
+ * @interface SimpleArrayStringSchema
+ * @extends BasicSchema
+ * @property type - The type of the schema, which is always "string".
+ * @property [primary] - Optional. Indicates whether this is a primary property.
+ */
+interface SimpleArrayStringSchema extends BasicSchema {
+  type: "string";
+  primary?: boolean;
+}
+
+/**
+ * A simple object schema with properties.
+ * @interface SimpleObjectSchema
+ * @extends BasicSchema
+ * @property type - The type of the schema, which is always "object".
+ * @property properties - The properties of the object.
+ * @property required - The required properties of the object.
+ */
+export interface SimpleObjectSchema extends BasicSchema {
+  type: "object";
+  properties: Record<string, SimpleObjectStringSchema>;
+  required: string[];
+}
+
+/**
+ * A simple array item schema with properties.
+ * @interface SimpleArrayItemSchema
+ * @extends BasicSchema
+ * @property type - The type of the schema, which is always "object".
+ * @property properties - The properties of the array item.
+ * @property required - The required properties of the array item.
+ */
+export interface SimpleArrayItemSchema extends BasicSchema {
+  type: "object";
+  properties: Record<string, SimpleArrayStringSchema>;
+  required: string[];
+}
+
+/**
+ * Extracts a structured object from a web page.
+ *
+ * @param page - The Playwright Page object from which to extract the data.
+ * @param options.label - A label for this extraction process, used for billing and monitoring.
+ * @param options.entityName - The name of the entity being extracted. it must be between 1 and 50 characters long and can only contain letters, digits, periods, underscores, and hyphens.
+ * @param options.entitySchema - The schema of the entity being extracted.
+ * @param options.strategy - Optional. The strategy to use for extraction, if not provided, the html strategy with claude haiku will be used.
+ * @param options.prompt - Optional. A prompt to guide the extraction process.
+ * @param options.optionalPropertiesInvalidator - Optional. A function to invalidate optional properties.
+ * @param options.variantKey - Optional. A variant key for the extraction process.
+ * @param options.apiKey - Optional. An API key to use for the AI extraction. Extractions made with you API key will not be billed to your account.
+ * @returns A promise that resolves to the extracted object.
+ * @example
+ * ```typescript extractObjectFromPage
+ *  import { extractObjectFromPage } from "@intuned/sdk/optimized-extractors";
+ *
+ *  await page.goto("https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html")
+ *  const book = await extractObjectFromPage(page,
+ *    {
+ *      entityName: "book",
+ *      label: "book-extraction",
+ *      entitySchema: {
+ *        type: "object",
+ *        required: ["name","price","reviews"],
+ *        properties: {
+ *          name: {
+ *            type: "string",
+ *            description: "book name",
+ *          },
+ *          price: {
+ *            type: "string",
+ *            description: "book price"
+ *          },
+ *          reviews: {
+ *            type: "string",
+ *            description: "Number of reviews"
+ *          }
+ *
+ *        }
+ *      }
+ *    },
+ *  )
+ *
+ *  console.log(book)
+ *
+ *  // output:
+ *  // { name: 'A Light in the Attic', price: '£51.77', reviews: '0' }
+ *
+ * ```
+ */
+export declare function extractObjectFromPage(
+  page: Page,
+  options: {
+    label: string;
+    entityName: string;
+    entitySchema: SimpleObjectSchema;
+    strategy?: ImageStrategy | HtmlStrategy;
+    prompt?: string;
+    optionalPropertiesInvalidator?: (
+      result: Record<string, string | null> | null
+    ) => string[];
+    variantKey?: string;
+    apiKey?: string;
+  }
+): Promise<Record<string, string | null> | null>;
+
+/**
+ * Extracts a structured object from a locator.
+ *
+ * @param locator - The Playwright Locator object from which to extract the data.
+ * @param options.label - A label for this extraction process, used for billing and monitoring.
+ * @param options.entityName - The name of the entity being extracted. it must be between 1 and 50 characters long and can only contain letters, digits, periods, underscores, and hyphens.
+ * @param options.entitySchema - The schema of the entity being extracted.
+ * @param options.strategy - Optional. The strategy to use for extraction, if not provided, the html strategy with claude haiku will be used.
+ * @param options.prompt - Optional. A prompt to guide the extraction process.
+ * @param options.optionalPropertiesInvalidator - Optional. A function to invalidate optional properties.
+ * @param options.variantKey - Optional. A variant key for the extraction process.
+ * @param options.apiKey - Optional. An API key to use for the AI extraction. Extractions made with you API key will not be billed to your account.
+ * @returns A promise that resolves to the extracted object.
+ *
+ * @example
+ * ```typescript extractObjectFromLocator
+ *  import { extractObjectFromLocator } from "@intuned/sdk/optimized-extractors";
+ *
+ *  await page.goto("https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html")
+ *  const book = await extractObjectFromLocator(page.locator(".page_inner"),
+ *    {
+ *      entityName: "book",
+ *      label: "book-extraction",
+ *      entitySchema: {
+ *        type: "object",
+ *        required: ["name","price","reviews"],
+ *        properties: {
+ *          name: {
+ *            type: "string",
+ *            description: "book name",
+ *          },
+ *          price: {
+ *            type: "string",
+ *            description: "book price"
+ *          },
+ *          reviews: {
+ *            type: "string",
+ *            description: "Number of reviews"
+ *          }
+ *
+ *        }
+ *      }
+ *    },
+ *  )
+ *
+ *  console.log(book)
+ *
+ *  // output:
+ *  // { name: 'A Light in the Attic', price: '£51.77', reviews: '0' }
+ *
+ * ```
+ */
+export declare function extractObjectFromLocator(
+  locator: Locator,
+  options: {
+    label: string;
+    entityName: string;
+    entitySchema: SimpleObjectSchema;
+    strategy?: ImageStrategy | HtmlStrategy;
+    prompt?: string;
+    optionalPropertiesInvalidator?: (
+      result: Record<string, string | null> | null
+    ) => string[];
+    variantKey?: string;
+    apiKey?: string;
+  }
+): Promise<Record<string, string | null> | null>;