@datocms/cma-client 5.1.1 → 5.1.3

package/dist/cjs/utilities/structuredText.js

@@ -1,371 +0,0 @@
-"use strict";
-/**
- * Tree manipulation utilities for DatoCMS structured text documents.
- *
- * Provides a set of low-level utilities for visiting, transforming, and querying
- * structured text trees. Works with all tree variants (regular, request, nested).
- */
-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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.everyNodeAsync = exports.everyNode = exports.someNodeAsync = exports.someNode = exports.reduceNodesAsync = exports.reduceNodes = exports.filterNodesAsync = exports.filterNodes = exports.findAllNodesAsync = exports.findAllNodes = exports.mapNodesAsync = exports.mapNodes = exports.forEachNodeAsync = exports.forEachNode = void 0;
-/**
- * Check if a value has children property that is an array
- */
-function hasChildren(node) {
-    return (typeof node === 'object' &&
-        node !== null &&
-        'children' in node &&
-        Array.isArray(node.children));
-}
-/**
- * Visit every node in the Structured Text tree, calling the visitor function for each.
- * Uses pre-order traversal (parent is visited before its children).
- *
- * @template T - The type of the root node in the Structured Text tree
- * @param node - The root node to start visiting from
- * @param visitor - Synchronous function called for each node. Receives the node, its parent, and path through the Structured Text tree
- */
-function forEachNode(node, visitor, parent = null, path = []) {
-    // Visit current node
-    visitor(node, parent, path);
-    // Recursively visit children
-    if (hasChildren(node)) {
-        for (let index = 0; index < node.children.length; index++) {
-            const child = node.children[index];
-            forEachNode(child, visitor, node, [
-                ...path,
-                'children',
-                index,
-            ]);
-        }
-    }
-}
-exports.forEachNode = forEachNode;
-/**
- * Visit every node in the Structured Text tree, calling the visitor function for each.
- * Uses pre-order traversal (parent is visited before its children).
- *
- * @template T - The type of the root node in the Structured Text tree
- * @param node - The root node to start visiting from
- * @param visitor - Asynchronous function called for each node. Receives the node, its parent, and path through the Structured Text tree
- * @returns Promise that resolves when all nodes have been visited
- */
-function forEachNodeAsync(node, visitor, parent = null, path = []) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // Visit current node
-        yield visitor(node, parent, path);
-        // Recursively visit children
-        if (hasChildren(node)) {
-            for (let index = 0; index < node.children.length; index++) {
-                const child = node.children[index];
-                yield forEachNodeAsync(child, visitor, node, [
-                    ...path,
-                    'children',
-                    index,
-                ]);
-            }
-        }
-    });
-}
-exports.forEachNodeAsync = forEachNodeAsync;
-/**
- * Transform nodes in the Structured Text tree by applying a mapping function.
- * Creates a new tree structure with transformed nodes while preserving the Structured Text tree hierarchy.
- *
- * @template T - The type of nodes in the input Structured Text tree
- * @template R - The type of nodes in the output tree
- * @param node - The root node to start mapping from
- * @param mapper - Synchronous function that transforms each node. Receives the node, its parent, and path
- * @returns The transformed tree
- */
-function mapNodes(node, mapper, parent = null, path = []) {
-    // Transform current node
-    const transformedNode = mapper(node, parent, path);
-    // If the original node has children, recursively transform them
-    if (hasChildren(node) &&
-        typeof transformedNode === 'object' &&
-        transformedNode !== null) {
-        const transformedChildren = node.children.map((child, index) => mapNodes(child, mapper, node, [
-            ...path,
-            'children',
-            index,
-        ]));
-        return Object.assign(Object.assign({}, transformedNode), { children: transformedChildren });
-    }
-    return transformedNode;
-}
-exports.mapNodes = mapNodes;
-/**
- * Transform nodes in the Structured Text tree by applying a mapping function.
- * Creates a new tree structure with transformed nodes while preserving the Structured Text tree hierarchy.
- *
- * @template T - The type of nodes in the input Structured Text tree
- * @template R - The type of nodes in the output tree
- * @param node - The root node to start mapping from
- * @param mapper - Asynchronous function that transforms each node. Receives the node, its parent, and path
- * @returns Promise that resolves to the transformed tree
- */
-function mapNodesAsync(node, mapper, parent = null, path = []) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // Transform current node
-        const transformedNode = yield mapper(node, parent, path);
-        // If the original node has children, recursively transform them
-        if (hasChildren(node) &&
-            typeof transformedNode === 'object' &&
-            transformedNode !== null) {
-            const transformedChildren = yield Promise.all(node.children.map((child, index) => mapNodesAsync(child, mapper, node, [
-                ...path,
-                'children',
-                index,
-            ])));
-            return Object.assign(Object.assign({}, transformedNode), { children: transformedChildren });
-        }
-        return transformedNode;
-    });
-}
-exports.mapNodesAsync = mapNodesAsync;
-/**
- * Find all nodes that match the predicate function using depth-first search.
- * Returns an array containing all matching nodes along with their paths through the Structured Text tree.
- *
- * @template T - The type of nodes in the Structured Text tree
- * @param node - The root node to start searching from
- * @param predicate - Synchronous function that tests each node. Should return true for desired nodes
- * @returns Array of objects, each containing a matching node and its path
- */
-function findAllNodes(node, predicate, parent = null, path = []) {
-    const results = [];
-    forEachNode(node, (currentNode, currentParent, currentPath) => {
-        if (predicate(currentNode, currentParent, currentPath)) {
-            results.push({ node: currentNode, path: currentPath });
-        }
-    }, parent, path);
-    return results;
-}
-exports.findAllNodes = findAllNodes;
-/**
- * Find all nodes that match the predicate function using depth-first search.
- * Returns an array containing all matching nodes along with their paths through the Structured Text tree.
- *
- * @template T - The type of nodes in the Structured Text tree
- * @param node - The root node to start searching from
- * @param predicate - Asynchronous function that tests each node. Should return true for desired nodes
- * @returns Promise that resolves to an array of objects, each containing a matching node and its path
- */
-function findAllNodesAsync(node, predicate, parent = null, path = []) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const results = [];
-        yield forEachNodeAsync(node, (currentNode, currentParent, currentPath) => __awaiter(this, void 0, void 0, function* () {
-            if (yield predicate(currentNode, currentParent, currentPath)) {
-                results.push({ node: currentNode, path: currentPath });
-            }
-        }), parent, path);
-        return results;
-    });
-}
-exports.findAllNodesAsync = findAllNodesAsync;
-/**
- * Filter nodes in the Structured Text tree, removing those that don't match the predicate.
- * Creates a new tree structure containing only nodes that pass the predicate test.
- * Maintains the Structured Text tree hierarchy - if a parent node is kept, its structure is preserved.
- *
- * @template T - The type of nodes in the Structured Text tree
- * @param node - The root node to start filtering from
- * @param predicate - Synchronous function that tests each node. Nodes returning false are removed
- * @returns The filtered tree, or null if root node is filtered out
- */
-function filterNodes(node, predicate, parent = null, path = []) {
-    // If current node doesn't match predicate, return null
-    if (!predicate(node, parent, path)) {
-        return null;
-    }
-    // If node has no children, return it as-is
-    if (!hasChildren(node)) {
-        return node;
-    }
-    // Filter children recursively
-    const childrenResults = node.children.map((child, index) => filterNodes(child, predicate, node, [
-        ...path,
-        'children',
-        index,
-    ]));
-    const filteredChildren = childrenResults.filter((child) => child !== null);
-    return Object.assign(Object.assign({}, node), { children: filteredChildren });
-}
-exports.filterNodes = filterNodes;
-/**
- * Filter nodes in the Structured Text tree, removing those that don't match the predicate.
- * Creates a new tree structure containing only nodes that pass the predicate test.
- * Maintains the Structured Text tree hierarchy - if a parent node is kept, its structure is preserved.
- *
- * @template T - The type of nodes in the Structured Text tree
- * @param node - The root node to start filtering from
- * @param predicate - Asynchronous function that tests each node. Nodes returning false are removed
- * @returns Promise that resolves to the filtered tree, or null if root node is filtered out
- */
-function filterNodesAsync(node, predicate, parent = null, path = []) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // If current node doesn't match predicate, return null
-        if (!(yield predicate(node, parent, path))) {
-            return null;
-        }
-        // If node has no children, return it as-is
-        if (!hasChildren(node)) {
-            return node;
-        }
-        // Filter children recursively
-        const childrenResults = yield Promise.all(node.children.map((child, index) => filterNodesAsync(child, predicate, node, [
-            ...path,
-            'children',
-            index,
-        ])));
-        const filteredChildren = childrenResults.filter((child) => child !== null);
-        return Object.assign(Object.assign({}, node), { children: filteredChildren });
-    });
-}
-exports.filterNodesAsync = filterNodesAsync;
-/**
- * Reduce the Structured Text tree to a single value by applying a reducer function to each node.
- * Uses pre-order traversal (parent is processed before its children).
- * The reducer function is called for each node with the current accumulator value.
- *
- * @template T - The type of nodes in the Structured Text tree
- * @template R - The type of the accumulated result
- * @param node - The root node to start reducing from
- * @param reducer - Synchronous function that processes each node and updates the accumulator
- * @param initialValue - The initial value for the accumulator
- * @returns The final accumulated value
- */
-function reduceNodes(node, reducer, initialValue, parent = null, path = []) {
-    let accumulator = initialValue;
-    forEachNode(node, (currentNode, currentParent, currentPath) => {
-        accumulator = reducer(accumulator, currentNode, currentParent, currentPath);
-    }, parent, path);
-    return accumulator;
-}
-exports.reduceNodes = reduceNodes;
-/**
- * Reduce the Structured Text tree to a single value by applying a reducer function to each node.
- * Uses pre-order traversal (parent is processed before its children).
- * The reducer function is called for each node with the current accumulator value.
- *
- * @template T - The type of nodes in the Structured Text tree
- * @template R - The type of the accumulated result
- * @param node - The root node to start reducing from
- * @param reducer - Asynchronous function that processes each node and updates the accumulator
- * @param initialValue - The initial value for the accumulator
- * @returns Promise that resolves to the final accumulated value
- */
-function reduceNodesAsync(node, reducer, initialValue, parent = null, path = []) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let accumulator = initialValue;
-        yield forEachNodeAsync(node, (currentNode, currentParent, currentPath) => __awaiter(this, void 0, void 0, function* () {
-            accumulator = yield reducer(accumulator, currentNode, currentParent, currentPath);
-        }), parent, path);
-        return accumulator;
-    });
-}
-exports.reduceNodesAsync = reduceNodesAsync;
-/**
- * Check if any node in the Structured Text tree matches the predicate function.
- * Returns true as soon as the first matching node is found (short-circuit evaluation).
- *
- * @template T - The type of nodes in the Structured Text tree
- * @param node - The root node to start searching from
- * @param predicate - Synchronous function that tests each node. Should return true for matching nodes
- * @returns True if any node matches, false otherwise
- */
-function someNode(node, predicate, parent = null, path = []) {
-    // Check current node
-    if (predicate(node, parent, path)) {
-        return true;
-    }
-    // Recursively check children
-    if (hasChildren(node)) {
-        for (let index = 0; index < node.children.length; index++) {
-            const child = node.children[index];
-            if (someNode(child, predicate, node, [
-                ...path,
-                'children',
-                index,
-            ])) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-exports.someNode = someNode;
-/**
- * Check if any node in the Structured Text tree matches the predicate function.
- * Returns true as soon as the first matching node is found (short-circuit evaluation).
- *
- * @template T - The type of nodes in the Structured Text tree
- * @param node - The root node to start searching from
- * @param predicate - Asynchronous function that tests each node. Should return true for matching nodes
- * @returns Promise that resolves to true if any node matches, false otherwise
- */
-function someNodeAsync(node, predicate, parent = null, path = []) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // Check current node
-        if (yield predicate(node, parent, path)) {
-            return true;
-        }
-        // Recursively check children
-        if (hasChildren(node)) {
-            for (let index = 0; index < node.children.length; index++) {
-                const child = node.children[index];
-                if (yield someNodeAsync(child, predicate, node, [
-                    ...path,
-                    'children',
-                    index,
-                ])) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    });
-}
-exports.someNodeAsync = someNodeAsync;
-/**
- * Check if every node in the Structured Text tree matches the predicate function.
- * Returns false as soon as the first non-matching node is found (short-circuit evaluation).
- *
- * @template T - The type of nodes in the Structured Text tree
- * @param node - The root node to start testing from
- * @param predicate - Synchronous function that tests each node. Should return true for valid nodes
- * @returns True if all nodes match, false otherwise
- */
-function everyNode(node, predicate, parent = null, path = []) {
-    return !someNode(node, (currentNode, currentParent, currentPath) => {
-        return !predicate(currentNode, currentParent, currentPath);
-    }, parent, path);
-}
-exports.everyNode = everyNode;
-/**
- * Check if every node in the Structured Text tree matches the predicate function.
- * Returns false as soon as the first non-matching node is found (short-circuit evaluation).
- *
- * @template T - The type of nodes in the Structured Text tree
- * @param node - The root node to start testing from
- * @param predicate - Asynchronous function that tests each node. Should return true for valid nodes
- * @returns Promise that resolves to true if all nodes match, false otherwise
- */
-function everyNodeAsync(node, predicate, parent = null, path = []) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return !(yield someNodeAsync(node, (currentNode, currentParent, currentPath) => __awaiter(this, void 0, void 0, function* () {
-            return !(yield predicate(currentNode, currentParent, currentPath));
-        }), parent, path));
-    });
-}
-exports.everyNodeAsync = everyNodeAsync;
-//# sourceMappingURL=structuredText.js.map

package/dist/cjs/utilities/structuredText.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"structuredText.js","sourceRoot":"","sources":["../../../src/utilities/structuredText.ts"],"names":[],"mappings":"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"}

package/dist/esm/generated/SchemaTypes.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=SchemaTypes.js.map

package/dist/esm/generated/SchemaTypes.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SchemaTypes.js","sourceRoot":"","sources":["../../../src/generated/SchemaTypes.ts"],"names":[],"mappings":""}

package/dist/esm/generated/SimpleSchemaTypes.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=SimpleSchemaTypes.js.map

package/dist/esm/generated/SimpleSchemaTypes.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SimpleSchemaTypes.js","sourceRoot":"","sources":["../../../src/generated/SimpleSchemaTypes.ts"],"names":[],"mappings":""}

package/dist/esm/utilities/fieldValueLocalization.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"fieldValueLocalization.js","sourceRoot":"","sources":["../../../src/utilities/fieldValueLocalization.ts"],"names":[],"mappings":"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"}

package/dist/esm/utilities/structuredText.d.ts

@@ -1,177 +0,0 @@
-/**
- * Tree manipulation utilities for DatoCMS structured text documents.
- *
- * Provides a set of low-level utilities for visiting, transforming, and querying
- * structured text trees. Works with all tree variants (regular, request, nested).
- */
-/**
- * Recursively extract all possible node types that can appear in a tree structure
- */
-type AllNodesInTree<T, Depth extends number = 10> = Depth extends 0 ? T extends readonly unknown[] ? never : T : T extends readonly (infer U)[] ? AllNodesInTree<U, Prev<Depth>> : T extends {
-    children: infer Children;
-} ? T | AllNodesInTree<Children, Prev<Depth>> : T;
-type Prev<T extends number> = T extends 0 ? 0 : T extends 1 ? 0 : T extends 2 ? 1 : T extends 3 ? 2 : T extends 4 ? 3 : T extends 5 ? 4 : T extends 6 ? 5 : T extends 7 ? 6 : T extends 8 ? 7 : T extends 9 ? 8 : T extends 10 ? 9 : number;
-/**
- * Path through the Structured Text tree structure
- */
-export type TreePath = readonly (string | number)[];
-/**
- * Generic predicate function type for Structured Text tree node filtering
- */
-export type NodePredicate<T, R> = (node: AllNodesInTree<T>, parent: AllNodesInTree<T> | null, path: TreePath) => R;
-/**
- * Visit every node in the Structured Text tree, calling the visitor function for each.
- * Uses pre-order traversal (parent is visited before its children).
- *
- * @template T - The type of the root node in the Structured Text tree
- * @param node - The root node to start visiting from
- * @param visitor - Synchronous function called for each node. Receives the node, its parent, and path through the Structured Text tree
- */
-export declare function forEachNode<T>(node: T, visitor: NodePredicate<T, void>, parent?: AllNodesInTree<T> | null, path?: TreePath): void;
-/**
- * Visit every node in the Structured Text tree, calling the visitor function for each.
- * Uses pre-order traversal (parent is visited before its children).
- *
- * @template T - The type of the root node in the Structured Text tree
- * @param node - The root node to start visiting from
- * @param visitor - Asynchronous function called for each node. Receives the node, its parent, and path through the Structured Text tree
- * @returns Promise that resolves when all nodes have been visited
- */
-export declare function forEachNodeAsync<T>(node: T, visitor: NodePredicate<T, Promise<void>>, parent?: AllNodesInTree<T> | null, path?: TreePath): Promise<void>;
-/**
- * Transform nodes in the Structured Text tree by applying a mapping function.
- * Creates a new tree structure with transformed nodes while preserving the Structured Text tree hierarchy.
- *
- * @template T - The type of nodes in the input Structured Text tree
- * @template R - The type of nodes in the output tree
- * @param node - The root node to start mapping from
- * @param mapper - Synchronous function that transforms each node. Receives the node, its parent, and path
- * @returns The transformed tree
- */
-export declare function mapNodes<T, R>(node: T, mapper: NodePredicate<T, R>, parent?: AllNodesInTree<T> | null, path?: TreePath): R;
-/**
- * Transform nodes in the Structured Text tree by applying a mapping function.
- * Creates a new tree structure with transformed nodes while preserving the Structured Text tree hierarchy.
- *
- * @template T - The type of nodes in the input Structured Text tree
- * @template R - The type of nodes in the output tree
- * @param node - The root node to start mapping from
- * @param mapper - Asynchronous function that transforms each node. Receives the node, its parent, and path
- * @returns Promise that resolves to the transformed tree
- */
-export declare function mapNodesAsync<T, R>(node: T, mapper: NodePredicate<T, Promise<R>>, parent?: AllNodesInTree<T> | null, path?: TreePath): Promise<R>;
-/**
- * Find all nodes that match the predicate function using depth-first search.
- * Returns an array containing all matching nodes along with their paths through the Structured Text tree.
- *
- * @template T - The type of nodes in the Structured Text tree
- * @param node - The root node to start searching from
- * @param predicate - Synchronous function that tests each node. Should return true for desired nodes
- * @returns Array of objects, each containing a matching node and its path
- */
-export declare function findAllNodes<T>(node: T, predicate: NodePredicate<T, boolean>, parent?: AllNodesInTree<T> | null, path?: TreePath): Array<{
-    node: AllNodesInTree<T>;
-    path: TreePath;
-}>;
-/**
- * Find all nodes that match the predicate function using depth-first search.
- * Returns an array containing all matching nodes along with their paths through the Structured Text tree.
- *
- * @template T - The type of nodes in the Structured Text tree
- * @param node - The root node to start searching from
- * @param predicate - Asynchronous function that tests each node. Should return true for desired nodes
- * @returns Promise that resolves to an array of objects, each containing a matching node and its path
- */
-export declare function findAllNodesAsync<T>(node: T, predicate: NodePredicate<T, Promise<boolean>>, parent?: AllNodesInTree<T> | null, path?: TreePath): Promise<Array<{
-    node: AllNodesInTree<T>;
-    path: TreePath;
-}>>;
-/**
- * Filter nodes in the Structured Text tree, removing those that don't match the predicate.
- * Creates a new tree structure containing only nodes that pass the predicate test.
- * Maintains the Structured Text tree hierarchy - if a parent node is kept, its structure is preserved.
- *
- * @template T - The type of nodes in the Structured Text tree
- * @param node - The root node to start filtering from
- * @param predicate - Synchronous function that tests each node. Nodes returning false are removed
- * @returns The filtered tree, or null if root node is filtered out
- */
-export declare function filterNodes<T>(node: T, predicate: NodePredicate<T, boolean>, parent?: AllNodesInTree<T> | null, path?: TreePath): T | null;
-/**
- * Filter nodes in the Structured Text tree, removing those that don't match the predicate.
- * Creates a new tree structure containing only nodes that pass the predicate test.
- * Maintains the Structured Text tree hierarchy - if a parent node is kept, its structure is preserved.
- *
- * @template T - The type of nodes in the Structured Text tree
- * @param node - The root node to start filtering from
- * @param predicate - Asynchronous function that tests each node. Nodes returning false are removed
- * @returns Promise that resolves to the filtered tree, or null if root node is filtered out
- */
-export declare function filterNodesAsync<T>(node: T, predicate: NodePredicate<T, Promise<boolean>>, parent?: AllNodesInTree<T> | null, path?: TreePath): Promise<T | null>;
-/**
- * Reduce the Structured Text tree to a single value by applying a reducer function to each node.
- * Uses pre-order traversal (parent is processed before its children).
- * The reducer function is called for each node with the current accumulator value.
- *
- * @template T - The type of nodes in the Structured Text tree
- * @template R - The type of the accumulated result
- * @param node - The root node to start reducing from
- * @param reducer - Synchronous function that processes each node and updates the accumulator
- * @param initialValue - The initial value for the accumulator
- * @returns The final accumulated value
- */
-export declare function reduceNodes<T, R>(node: T, reducer: (accumulator: R, node: AllNodesInTree<T>, parent: AllNodesInTree<T> | null, path: TreePath) => R, initialValue: R, parent?: AllNodesInTree<T> | null, path?: TreePath): R;
-/**
- * Reduce the Structured Text tree to a single value by applying a reducer function to each node.
- * Uses pre-order traversal (parent is processed before its children).
- * The reducer function is called for each node with the current accumulator value.
- *
- * @template T - The type of nodes in the Structured Text tree
- * @template R - The type of the accumulated result
- * @param node - The root node to start reducing from
- * @param reducer - Asynchronous function that processes each node and updates the accumulator
- * @param initialValue - The initial value for the accumulator
- * @returns Promise that resolves to the final accumulated value
- */
-export declare function reduceNodesAsync<T, R>(node: T, reducer: (accumulator: R, node: AllNodesInTree<T>, parent: AllNodesInTree<T> | null, path: TreePath) => Promise<R>, initialValue: R, parent?: AllNodesInTree<T> | null, path?: TreePath): Promise<R>;
-/**
- * Check if any node in the Structured Text tree matches the predicate function.
- * Returns true as soon as the first matching node is found (short-circuit evaluation).
- *
- * @template T - The type of nodes in the Structured Text tree
- * @param node - The root node to start searching from
- * @param predicate - Synchronous function that tests each node. Should return true for matching nodes
- * @returns True if any node matches, false otherwise
- */
-export declare function someNode<T>(node: T, predicate: NodePredicate<T, boolean>, parent?: AllNodesInTree<T> | null, path?: TreePath): boolean;
-/**
- * Check if any node in the Structured Text tree matches the predicate function.
- * Returns true as soon as the first matching node is found (short-circuit evaluation).
- *
- * @template T - The type of nodes in the Structured Text tree
- * @param node - The root node to start searching from
- * @param predicate - Asynchronous function that tests each node. Should return true for matching nodes
- * @returns Promise that resolves to true if any node matches, false otherwise
- */
-export declare function someNodeAsync<T>(node: T, predicate: NodePredicate<T, Promise<boolean>>, parent?: AllNodesInTree<T> | null, path?: TreePath): Promise<boolean>;
-/**
- * Check if every node in the Structured Text tree matches the predicate function.
- * Returns false as soon as the first non-matching node is found (short-circuit evaluation).
- *
- * @template T - The type of nodes in the Structured Text tree
- * @param node - The root node to start testing from
- * @param predicate - Synchronous function that tests each node. Should return true for valid nodes
- * @returns True if all nodes match, false otherwise
- */
-export declare function everyNode<T>(node: T, predicate: NodePredicate<T, boolean>, parent?: AllNodesInTree<T> | null, path?: TreePath): boolean;
-/**
- * Check if every node in the Structured Text tree matches the predicate function.
- * Returns false as soon as the first non-matching node is found (short-circuit evaluation).
- *
- * @template T - The type of nodes in the Structured Text tree
- * @param node - The root node to start testing from
- * @param predicate - Asynchronous function that tests each node. Should return true for valid nodes
- * @returns Promise that resolves to true if all nodes match, false otherwise
- */
-export declare function everyNodeAsync<T>(node: T, predicate: NodePredicate<T, Promise<boolean>>, parent?: AllNodesInTree<T> | null, path?: TreePath): Promise<boolean>;
-export {};