@exellix/graph-engine 6.0.0

package/dist/src/runtime/buildRunLog.js

@@ -0,0 +1,234 @@
+import { AI_TASKS_LOGXER_RUN_ID_METADATA_KEY, AI_TASKS_RUN_LOG_METADATA_KEY, DEFAULT_MAX_RUN_LOG_DATA_JSON_CHARS, DEFAULT_MAX_RUN_LOG_ENTRIES, } from '../types/runLog.js';
+function safeJsonLen(value) {
+    try {
+        return JSON.stringify(value).length;
+    }
+    catch {
+        return String(value).length;
+    }
+}
+/** Truncate `data` for HTTP/console payloads; returns replacement suitable for `RunLogEntry.data`. */
+export function truncateRunLogData(data, maxJsonChars) {
+    if (data === undefined)
+        return undefined;
+    const len = safeJsonLen(data);
+    if (len <= maxJsonChars)
+        return data;
+    let preview;
+    try {
+        preview = JSON.stringify(data);
+    }
+    catch {
+        preview = String(data);
+    }
+    if (preview.length > maxJsonChars) {
+        preview = preview.slice(0, maxJsonChars);
+    }
+    return { _truncated: true, preview };
+}
+function isRunLogLevel(x) {
+    return x === 'debug' || x === 'info' || x === 'warn' || x === 'error';
+}
+function isRunLogScope(x) {
+    return (x === 'graph' ||
+        x === 'node' ||
+        x === 'task' ||
+        x === 'narrix' ||
+        x === 'logxer' ||
+        x === 'pipeline');
+}
+/** Normalize @exellix/ai-tasks epoch-ms or ISO `ts` to epoch ms for exellix-graph `RunLogEntry`. */
+export function parseRunLogEntryTs(v) {
+    if (typeof v === 'number' && Number.isFinite(v))
+        return v;
+    if (typeof v === 'string' && v.length > 0) {
+        const ms = Date.parse(v);
+        if (!Number.isNaN(ms))
+            return ms;
+    }
+    return Date.now();
+}
+/** Normalize entries from ai-tasks metadata (best-effort). */
+export function normalizeExternalRunLogEntries(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    const out = [];
+    for (const row of raw) {
+        if (row == null || typeof row !== 'object')
+            continue;
+        const r = row;
+        const ts = parseRunLogEntryTs(r.ts);
+        const level = isRunLogLevel(r.level) ? r.level : 'info';
+        const scope = isRunLogScope(r.scope) ? r.scope : 'task';
+        const message = typeof r.message === 'string' ? r.message : String(r.message ?? '');
+        const nodeId = r.nodeId != null ? String(r.nodeId) : undefined;
+        const skillKey = typeof r.skillKey === 'string' && r.skillKey.length > 0 ? r.skillKey : undefined;
+        const taskId = typeof r.taskId === 'string' && r.taskId.length > 0 ? r.taskId : undefined;
+        const correlationIds = r.correlationIds != null && typeof r.correlationIds === 'object' && !Array.isArray(r.correlationIds)
+            ? r.correlationIds
+            : undefined;
+        const data = 'data' in r ? r.data : undefined;
+        out.push({
+            ts,
+            level,
+            scope,
+            ...(nodeId ? { nodeId } : {}),
+            ...(skillKey ? { skillKey } : {}),
+            ...(taskId ? { taskId } : {}),
+            ...(correlationIds ? { correlationIds } : {}),
+            message,
+            ...(data !== undefined ? { data } : {}),
+        });
+    }
+    return out;
+}
+export function extractTaskRunLogFromMetadata(metadata) {
+    if (metadata == null || typeof metadata !== 'object' || Array.isArray(metadata))
+        return [];
+    const m = metadata;
+    return normalizeExternalRunLogEntries(m[AI_TASKS_RUN_LOG_METADATA_KEY]);
+}
+export function extractLogxerCorrelationFromMetadata(metadata) {
+    if (metadata == null || typeof metadata !== 'object' || Array.isArray(metadata))
+        return undefined;
+    const m = metadata;
+    const runId = m[AI_TASKS_LOGXER_RUN_ID_METADATA_KEY];
+    if (typeof runId === 'string' && runId.length > 0)
+        return runId;
+    return undefined;
+}
+function traceNodeData(entry, summary) {
+    if (summary) {
+        const d = {
+            skillKey: entry.skillKey,
+            durationMs: entry.durationMs,
+            ok: entry.ok,
+        };
+        if (entry.activityId)
+            d.activityId = entry.activityId;
+        if (entry.error) {
+            d.error = {
+                message: entry.error.message,
+                ...(entry.error.code ? { code: entry.error.code } : {}),
+            };
+        }
+        return d;
+    }
+    const d = {
+        startedAt: entry.startedAt,
+        endedAt: entry.endedAt,
+        skillKey: entry.skillKey,
+        ok: entry.ok,
+        durationMs: entry.durationMs,
+    };
+    if (entry.activityId)
+        d.activityId = entry.activityId;
+    if (entry.summary)
+        d.summary = entry.summary;
+    if (entry.error)
+        d.error = entry.error;
+    return d;
+}
+/**
+ * Build merged `runLog` for a completed graph run from execution trace + optional per-task lines.
+ */
+export function buildRunLog(opts) {
+    const { mode, maxEntries, maxDataJsonChars, jobId, taskId, graphId, graphStatus, graphRunStartedAt, execution, taskAppendedEntries = [], logxerCorrelationId: inputCorrelation, } = opts;
+    if (mode === 'off') {
+        return {
+            ...(inputCorrelation ? { logxerCorrelationId: inputCorrelation } : {}),
+        };
+    }
+    const summary = mode === 'summary';
+    const graphEndedAt = Date.now();
+    const traceRoot = execution._trace;
+    const nodesRaw = traceRoot != null &&
+        typeof traceRoot === 'object' &&
+        !Array.isArray(traceRoot) &&
+        traceRoot.nodes != null &&
+        typeof traceRoot.nodes === 'object'
+        ? traceRoot.nodes
+        : {};
+    const startedTimes = [];
+    for (const e of Object.values(nodesRaw)) {
+        if (e == null || typeof e !== 'object')
+            continue;
+        const s = e.startedAt;
+        if (typeof s === 'number' && Number.isFinite(s))
+            startedTimes.push(s);
+    }
+    const inferredStart = startedTimes.length > 0 ? Math.min(...startedTimes) : graphEndedAt;
+    const graphStartedAt = typeof graphRunStartedAt === 'number' && Number.isFinite(graphRunStartedAt)
+        ? graphRunStartedAt
+        : inferredStart;
+    const built = [];
+    built.push({
+        ts: graphStartedAt,
+        level: 'info',
+        scope: 'graph',
+        message: `Graph run started (${graphId})`,
+        data: truncateRunLogData({ jobId, taskId, graphId }, maxDataJsonChars),
+    });
+    const nodeIds = Object.keys(nodesRaw).sort((a, b) => {
+        const ea = nodesRaw[a];
+        const eb = nodesRaw[b];
+        const sa = ea && typeof ea.startedAt === 'number' ? ea.startedAt : 0;
+        const sb = eb && typeof eb.startedAt === 'number' ? eb.startedAt : 0;
+        return sa - sb || a.localeCompare(b);
+    });
+    for (const nodeId of nodeIds) {
+        const entry = nodesRaw[nodeId];
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const level = entry.ok ? 'info' : 'error';
+        const msg = entry.ok
+            ? `Node ${nodeId} completed (${entry.skillKey}, ${entry.durationMs}ms)`
+            : `Node ${nodeId} failed (${entry.skillKey})`;
+        built.push({
+            ts: typeof entry.endedAt === 'number' ? entry.endedAt : graphEndedAt,
+            level,
+            scope: 'node',
+            nodeId,
+            message: msg,
+            data: truncateRunLogData(traceNodeData(entry, summary), maxDataJsonChars),
+        });
+    }
+    built.push({
+        ts: graphEndedAt,
+        level: graphStatus === 'failed' ? 'error' : 'info',
+        scope: 'graph',
+        message: graphStatus === 'failed'
+            ? `Graph run finished (${graphId}, failed)`
+            : `Graph run finished (${graphId}, completed)`,
+        data: truncateRunLogData({ jobId, taskId, graphId, status: graphStatus }, maxDataJsonChars),
+    });
+    built.push(...taskAppendedEntries);
+    built.sort((a, b) => a.ts - b.ts || 0);
+    let runLogTruncated = false;
+    let runLogOmittedCount = 0;
+    let out = built;
+    if (built.length > maxEntries) {
+        runLogTruncated = true;
+        runLogOmittedCount = built.length - maxEntries;
+        out = built.slice(0, maxEntries);
+    }
+    const withTruncatedData = out.map((row) => ({
+        ...row,
+        data: row.data === undefined
+            ? undefined
+            : truncateRunLogData(row.data, maxDataJsonChars),
+    }));
+    return {
+        runLog: withTruncatedData,
+        ...(runLogTruncated ? { runLogTruncated, runLogOmittedCount } : {}),
+        ...(inputCorrelation ? { logxerCorrelationId: inputCorrelation } : {}),
+    };
+}
+export function resolveRunLogLimits(input) {
+    const mode = input.runLogMode ?? input.defaults?.runLogMode ?? 'summary';
+    const maxEntries = Math.max(1, input.maxRunLogEntries ?? input.defaults?.maxRunLogEntries ?? DEFAULT_MAX_RUN_LOG_ENTRIES);
+    const maxDataJsonChars = Math.max(64, input.maxRunLogDataJsonChars ??
+        input.defaults?.maxRunLogDataJsonChars ??
+        DEFAULT_MAX_RUN_LOG_DATA_JSON_CHARS);
+    return { mode, maxEntries, maxDataJsonChars };
+}

package/dist/src/runtime/buildRunTaskTaskConfigurationForward.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Builds the `RunTaskRequest.taskConfiguration` blob for `@exellix/ai-tasks` ≥ 7.7 compile-at-invoke.
+ * Root-level fields already lifted by graph-engine are omitted; compile-only authoring (e.g.
+ * `aiTaskStrategies`, `aiTaskProfile`) remains on the blob.
+ */
+/**
+ * Subset of node `taskConfiguration` forwarded on `RunTaskRequest.taskConfiguration` for ai-tasks compile.
+ */
+export declare function buildRunTaskTaskConfigurationForward(taskConfiguration: Record<string, unknown> | undefined | null): Record<string, unknown> | undefined;

package/dist/src/runtime/buildRunTaskTaskConfigurationForward.js

@@ -0,0 +1,80 @@
+/**
+ * Builds the `RunTaskRequest.taskConfiguration` blob for `@exellix/ai-tasks` ≥ 7.7 compile-at-invoke.
+ * Root-level fields already lifted by graph-engine are omitted; compile-only authoring (e.g.
+ * `aiTaskStrategies`, `aiTaskProfile`) remains on the blob.
+ */
+const RUN_TASK_LIFTED_TASK_CONFIGURATION_KEYS = new Set([
+    'taskTypeId',
+    'executionStrategies',
+    'executionStrategyCatalogItems',
+    'modelConfig',
+    'llmCall',
+    'timeoutMs',
+    'narrix',
+    'narrixMode',
+    'narrixInput',
+    'narrixScope',
+    'inputStrategyKey',
+    'aiTasksOutputValidation',
+    'taskKind',
+    'autoValidateDecisionOutput',
+    'runTaskIdentity',
+    'identity',
+    'aiScoping',
+    'aiScopingOptions',
+    'templateRenderOptions',
+    'smartInputRenderOptions',
+    'templateTokens',
+    'aiEngineId',
+    'sessionId',
+    'agentType',
+    'gatewayDiagnostics',
+    'context',
+    'knowledge',
+]);
+/** Graph-engine / local-skill keys — not consumed by ai-tasks `runTask` compile. */
+const TASK_CONFIGURATION_GRAPH_ENGINE_ONLY_KEYS = new Set([
+    'stepRetryPolicy',
+    'concurrency',
+    'memoryKey',
+    'rules',
+    'firstMatchWins',
+    'defaultOutput',
+    'sensitivityAnalysis',
+    'scopingMapId',
+    'entityIdPath',
+    'questionId',
+    'pack',
+    'opDb',
+    'entityTypePath',
+    'staticEntityType',
+    'payloadPath',
+    'questionTitle',
+    'phase',
+    'seedThingIdPath',
+    'artifactThingType',
+    'xmemoryNamespace',
+    'mergeInferencePaths',
+    'mergeDecisionPaths',
+]);
+function isPlainObject(v) {
+    return v != null && typeof v === 'object' && !Array.isArray(v);
+}
+/**
+ * Subset of node `taskConfiguration` forwarded on `RunTaskRequest.taskConfiguration` for ai-tasks compile.
+ */
+export function buildRunTaskTaskConfigurationForward(taskConfiguration) {
+    if (!isPlainObject(taskConfiguration))
+        return undefined;
+    const out = {};
+    for (const [key, value] of Object.entries(taskConfiguration)) {
+        if (RUN_TASK_LIFTED_TASK_CONFIGURATION_KEYS.has(key))
+            continue;
+        if (TASK_CONFIGURATION_GRAPH_ENGINE_ONLY_KEYS.has(key))
+            continue;
+        if (value === undefined)
+            continue;
+        out[key] = value;
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}

package/dist/src/runtime/buildTaskNodeJobContext.d.ts

@@ -0,0 +1,11 @@
+import type { TaskNode } from '../types/refs.js';
+/**
+ * Builds `RunTaskRequest.jobContext` from `jobContextMapping` and `scope.contextualKnowledge`
+ * (same semantics for {@link executeNode} and {@link ExellixGraphRuntime}).
+ */
+export declare function buildTaskNodeJobContext(args: {
+    node: TaskNode;
+    jobMemory: unknown;
+    executionMemory: unknown;
+    variables: Record<string, unknown>;
+}): Record<string, unknown> | undefined;

package/dist/src/runtime/buildTaskNodeJobContext.js

@@ -0,0 +1,30 @@
+import { createMappedObject } from './memory.js';
+import { processContextualScope } from './contextualScope.js';
+/**
+ * Builds `RunTaskRequest.jobContext` from `jobContextMapping` and `scope.contextualKnowledge`
+ * (same semantics for {@link executeNode} and {@link ExellixGraphRuntime}).
+ */
+export function buildTaskNodeJobContext(args) {
+    const { node, jobMemory, executionMemory, variables } = args;
+    let jobContext;
+    if (node.jobContextMapping) {
+        const { map } = node.jobContextMapping;
+        if (map) {
+            jobContext = createMappedObject(map, {
+                node,
+                jobMemory,
+                executionMemory,
+                variables,
+            });
+        }
+    }
+    if (node.scope?.contextualKnowledge) {
+        const scopedContext = processContextualScope(node.scope, {
+            jobMemory,
+            variables,
+            node,
+        });
+        jobContext = { ...(jobContext ?? {}), ...scopedContext };
+    }
+    return jobContext;
+}

package/dist/src/runtime/canonicalModelUsed.d.ts

@@ -0,0 +1,6 @@
+import type { RunTaskResponse } from '../types/options.js';
+/**
+ * Single authoritative model id after gateway routing (G9). Prefer gateway/metadata fields
+ * over authored `modelConfig` on the outbound request.
+ */
+export declare function resolveCanonicalModelUsed(response: RunTaskResponse): string | undefined;

package/dist/src/runtime/canonicalModelUsed.js

@@ -0,0 +1,36 @@
+function isPlainObject(v) {
+    return v != null && typeof v === 'object' && !Array.isArray(v);
+}
+/**
+ * Single authoritative model id after gateway routing (G9). Prefer gateway/metadata fields
+ * over authored `modelConfig` on the outbound request.
+ */
+export function resolveCanonicalModelUsed(response) {
+    const r = response;
+    const meta = (r.metadata ?? r.meta);
+    if (meta != null) {
+        const direct = meta.modelUsed ?? meta.model;
+        if (typeof direct === 'string' && direct.trim() !== '')
+            return direct.trim();
+        const rawConfig = meta.rawConfig;
+        if (isPlainObject(rawConfig)) {
+            const fromRaw = rawConfig.modelUsed ?? rawConfig.model ?? rawConfig.skillModel ?? rawConfig.xynthesisModel;
+            if (typeof fromRaw === 'string' && fromRaw.trim() !== '')
+                return fromRaw.trim();
+        }
+        const gateway = meta.gateway ?? meta.gatewayDiagnostics;
+        if (isPlainObject(gateway)) {
+            const fromGw = gateway.modelUsed ?? gateway.model ?? gateway.resolvedModel;
+            if (typeof fromGw === 'string' && fromGw.trim() !== '')
+                return fromGw.trim();
+        }
+    }
+    const parsed = r.parsed;
+    if (isPlainObject(parsed)) {
+        const parsedMeta = parsed.meta;
+        if (isPlainObject(parsedMeta) && typeof parsedMeta.modelUsed === 'string' && parsedMeta.modelUsed.trim() !== '') {
+            return parsedMeta.modelUsed.trim();
+        }
+    }
+    return undefined;
+}

package/dist/src/runtime/contextualScope.d.ts

@@ -0,0 +1,7 @@
+import { GraphNode } from '../types/refs.js';
+export interface ScopeProcessingContext {
+    jobMemory: any;
+    variables: any;
+    node: GraphNode;
+}
+export declare function processContextualScope(scope: NonNullable<GraphNode['scope']>, context: ScopeProcessingContext): Record<string, any[]>;

package/dist/src/runtime/contextualScope.js

@@ -0,0 +1,121 @@
+import { LogicEngine } from '@x12i/graphenix';
+/**
+ * Resolves a placeholder string like "{{asset.zone}}" to a value
+ */
+function resolvePlaceholder(value, context) {
+    if (typeof value !== 'string')
+        return value;
+    // Check for {{...}} pattern
+    const match = value.match(/^\{\{(.+)\}\}$/);
+    if (!match)
+        return value;
+    const path = match[1].trim(); // e.g., "myRoot.someField"
+    // Map "{{root.rest...}}" to Graphenix: if `root` exists on job variables or job memory,
+    // resolve under $variables or $memory (no hardcoded domain roots).
+    let logicPath;
+    const firstDot = path.indexOf('.');
+    if (firstDot > 0) {
+        const root = path.slice(0, firstDot);
+        if (context.variables?.[root])
+            logicPath = '$variables.' + path;
+        else if (context.jobMemory?.[root])
+            logicPath = '$memory.' + path;
+        else
+            logicPath = '$' + path;
+    }
+    else {
+        logicPath = '$' + path;
+    }
+    // Create minimal context for LogicEngine
+    const execContext = {
+        state: {}, // No specific state for this resolution
+        variables: context.variables || {},
+        memory: context.jobMemory || {},
+        history: [],
+        outputs: { byKey: {}, byNodeId: {} },
+        nodeStatus: {},
+        node: context.node
+    };
+    const resolved = LogicEngine.resolveValue(logicPath, {}, execContext);
+    return resolved;
+}
+/**
+ * Safely access nested property
+ */
+function getNested(obj, path) {
+    return path.split('.').reduce((acc, part) => acc && acc[part], obj);
+}
+export function processContextualScope(scope, context) {
+    const result = {};
+    if (!scope.contextualKnowledge)
+        return result;
+    for (const item of scope.contextualKnowledge) {
+        const listName = item.list;
+        const sourceList = context.jobMemory?.[listName] || context.variables?.[listName];
+        if (!Array.isArray(sourceList)) {
+            result[listName] = [];
+            continue;
+        }
+        let filteredList = [...sourceList];
+        // Apply Filter
+        if (item.filter?.where) {
+            filteredList = filteredList.filter(entry => {
+                // All conditions must pass (AND logic)
+                return item.filter.where.every((condition) => {
+                    const entryValue = getNested(entry, condition.path);
+                    if (condition.eq !== undefined) {
+                        const targetVal = resolvePlaceholder(condition.eq, context);
+                        return entryValue === targetVal;
+                    }
+                    if (condition.eqAny !== undefined) {
+                        const targetList = Array.isArray(condition.eqAny)
+                            ? condition.eqAny.map((v) => resolvePlaceholder(v, context))
+                            : [resolvePlaceholder(condition.eqAny, context)];
+                        return targetList.includes(entryValue);
+                    }
+                    return false;
+                });
+            });
+        }
+        // Apply OrderBy
+        if (item.filter?.orderBy) {
+            filteredList.sort((a, b) => {
+                for (const rule of item.filter.orderBy) {
+                    const valA = getNested(a, rule.path);
+                    const valB = getNested(b, rule.path);
+                    if (valA < valB)
+                        return rule.direction === 'asc' ? -1 : 1;
+                    if (valA > valB)
+                        return rule.direction === 'asc' ? 1 : -1;
+                }
+                return 0;
+            });
+        }
+        // Apply Limit
+        if (item.filter?.limit !== undefined) {
+            filteredList = filteredList.slice(0, item.filter.limit);
+        }
+        // Apply Select
+        if (item.select) {
+            filteredList = filteredList.map(entry => {
+                const newEntry = {};
+                for (const field of item.select) {
+                    const val = getNested(entry, field);
+                    if (val !== undefined) {
+                        const parts = field.split('.');
+                        let current = newEntry;
+                        for (let i = 0; i < parts.length - 1; i++) {
+                            if (!current[parts[i]])
+                                current[parts[i]] = {};
+                            current = current[parts[i]];
+                        }
+                        current[parts[parts.length - 1]] = val;
+                    }
+                }
+                return newEntry;
+            });
+        }
+        result[listName] = filteredList;
+    }
+    return result;
+}

package/dist/src/runtime/dataFiltersEvaluation.d.ts

@@ -0,0 +1,60 @@
+import type { GraphPredicate } from '../types/refs.js';
+import { EXELLIX_STRUCTURED_DATA_FILTERS_V1, type StructuredDataFiltersV1 } from '../types/refs.js';
+/**
+ * Returns paths that are not valid roots for structured data-filter predicates
+ * (`data` or `data.*`). Empty when every leaf path is valid.
+ */
+export declare function getStructuredDataFilterPathViolations(predicate: GraphPredicate | undefined): string[];
+/**
+ * Evaluate a {@link GraphPredicate} tree where every leaf `path` is rooted at `data` or `data.*`,
+ * resolving values from `record` (the object that backs those paths).
+ *
+ * Semantics match {@link evaluateGraphPredicate} leaf operators (`exists`, `eq`) and boolean
+ * combinators (`all`, `any`, `not`), but paths are restricted to the `data` root only.
+ */
+export declare function evaluateDataFilterPredicate(predicate: GraphPredicate | undefined, record: Record<string, unknown>): boolean;
+export declare function isStructuredDataFiltersV1(value: unknown): value is StructuredDataFiltersV1;
+export type EvaluateStructuredDataFiltersResult = {
+    status: 'no_gate';
+    ok: true;
+    /** Human-readable: nothing to evaluate */
+    message: 'conditions.dataFilters was undefined or omitted';
+} | {
+    status: 'legacy_reference_ids';
+    ok: true;
+    /** Catalog / host-defined ids — not interpreted by graph-engine */
+    ids: string[];
+    message: 'conditions.dataFilters is a string[] of reference ids; graph-engine does not resolve ids. Evaluate in your host or pass a structured `{ version, when }` gate.';
+} | {
+    status: 'unsupported_shape';
+    ok: false;
+    message: string;
+} | {
+    status: 'evaluated';
+    ok: boolean;
+    version: typeof EXELLIX_STRUCTURED_DATA_FILTERS_V1;
+    /** When present, leaf paths that are not `data` / `data.*` (see `strictPaths`) */
+    invalidPaths?: string[];
+    predicateRejected?: boolean;
+};
+export type EvaluateStructuredDataFiltersOptions = {
+    /**
+     * When true (default), any leaf path outside `data` / `data.*` makes the result `ok: false`
+     * without evaluating the rest of the predicate. Canonical graph documents are validated the same way.
+     */
+    strictPaths?: boolean;
+};
+/**
+ * Public entry: interpret `conditions.dataFilters` (or the same field on `metadata.graphEntry`)
+ * against a plain JSON-serializable **record** object.
+ *
+ * - **Structured v1** (`{ version: "exellix.dataFilters.v1", when }`): evaluated here; leaf paths
+ *   must be `data` or `data.*` and read from `record`.
+ * - **Legacy `string[]`**: not evaluated; returned as {@link EvaluateStructuredDataFiltersResult} with
+ *   `status: "legacy_reference_ids"` so callers can apply catalog logic themselves.
+ * - **`undefined`**: `status: "no_gate"`, `ok: true`.
+ *
+ * This function performs **no I/O**. It does **not** evaluate `conditions.narratives` or
+ * `conditions.aiFilter` — those remain host / tooling concerns unless documented otherwise.
+ */
+export declare function evaluateStructuredDataFilters(dataFilters: string[] | StructuredDataFiltersV1 | undefined, record: Record<string, unknown>, options?: EvaluateStructuredDataFiltersOptions): EvaluateStructuredDataFiltersResult;