@react-native-firebase/firestore 23.8.6 → 24.0.0

package/dist/module/pipelines/expressions.js

@@ -0,0 +1,1273 @@
+"use strict";
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/**
+ * @beta
+ * Expression type kind (for internal/backend use).
+ */
+
+/**
+ * @beta
+ * Firestore value type for isType() checks.
+ */
+
+/**
+ * @beta
+ * Time granularity for timestampTruncate.
+ */
+
+/**
+ * @beta
+ * Boolean expression for pipeline `where()` (e.g. field('x').gt(0), and(...), or(...)).
+ */
+
+/**
+ * @beta
+ * Selectable for pipeline field selection/expressions (e.g. field('a').as('b'), expressions).
+ */
+
+/**
+ * @beta
+ * Field reference for pipeline stages.
+ */
+
+/**
+ * @beta
+ * Function expression (e.g. map(...), array(...)). Used as return type and in Expression union.
+ */
+
+/**
+ * @beta
+ * Constant/literal expression returned by `constant(...)`.
+ */
+
+/**
+ * @beta
+ * Expression type for pipeline parameters (field refs, literals, function results).
+ */
+
+/**
+ * @beta
+ * Ordering for pipeline sort() (e.g. Ordering.of(field('rating')).descending()).
+ */
+
+/**
+ * @beta
+ * Accumulator for pipeline aggregate() (e.g. avg(field('rating')).as('avgRating'), countAll().as('total')).
+ */
+
+/**
+ * @beta
+ * Aggregate function (e.g. countAll()). Alias for Accumulator.
+ */
+
+/**
+ * @beta
+ * An aggregate function with an output alias.
+ */
+
+/**
+ * @beta
+ * An expression with an output alias (implements Selectable).
+ */
+
+const RUNTIME_NODE_SYMBOL = Symbol.for('RNFBFirestorePipelineExpressionNode');
+function isRecord(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isPlainObject(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function isDocumentReferenceLike(value) {
+  return isRecord(value) && typeof value.path === 'string' && value.path.length > 0 && isRecord(value.firestore);
+}
+function isRuntimeNode(value) {
+  return isRecord(value) && value[RUNTIME_NODE_SYMBOL] === true;
+}
+function isOrderingNode(value) {
+  return isRuntimeNode(value) && value.__kind === 'ordering';
+}
+function containsRuntimeNode(value) {
+  if (isRuntimeNode(value)) {
+    return true;
+  }
+  if (Array.isArray(value)) {
+    return value.some(containsRuntimeNode);
+  }
+  if (!isRecord(value)) {
+    return false;
+  }
+  if (!isPlainObject(value)) {
+    return false;
+  }
+  return Object.values(value).some(containsRuntimeNode);
+}
+function toCanonicalFunctionName(name) {
+  switch (name) {
+    case 'gt':
+      return 'greaterThan';
+    case 'eq':
+      return 'equal';
+    case 'gte':
+      return 'greaterThanOrEqual';
+    case 'lt':
+      return 'lessThan';
+    case 'lte':
+      return 'lessThanOrEqual';
+    case 'avg':
+      return 'average';
+    case 'toLower':
+      return 'lower';
+    case 'toUpper':
+      return 'upper';
+    default:
+      return name;
+  }
+}
+const AGGREGATE_KINDS = new Set(['countAll', 'count', 'countIf', 'sum', 'average', 'minimum', 'maximum', 'countDistinct', 'first', 'last', 'arrayAgg', 'arrayAggDistinct']);
+const EXPRESSION_METHOD_NAMES = ['and', 'or', 'gt', 'greaterThan', 'eq', 'equal', 'notEqual', 'gte', 'greaterThanOrEqual', 'lt', 'lessThan', 'lte', 'lessThanOrEqual', 'exists', 'arrayContains', 'arrayContainsAny', 'arrayContainsAll', 'startsWith', 'endsWith', 'add', 'subtract', 'divide', 'multiply', 'documentId', 'sum', 'count', 'average', 'abs', 'ceil', 'floor', 'mod', 'round', 'conditional', 'countDistinct', 'first', 'last', 'arrayAgg', 'concat', 'sqrt', 'currentTimestamp', 'not', 'ifAbsent', 'ifError', 'toLower', 'toUpper', 'trim', 'substring', 'arrayAggDistinct', 'arrayConcat', 'arrayGet', 'arrayLength', 'arraySum', 'byteLength', 'charLength', 'collectionId', 'countIf', 'exp', 'join', 'like', 'ln', 'log', 'log10', 'maximum', 'minimum', 'pow', 'reverse', 'split', 'cosineDistance', 'dotProduct', 'equalAny', 'euclideanDistance', 'isAbsent', 'isError', 'isType', 'logicalMaximum', 'logicalMinimum', 'ltrim', 'notEqualAny', 'rand', 'rtrim', 'stringConcat', 'mapEntries', 'mapGet', 'mapKeys', 'mapMerge', 'mapRemove', 'mapSet', 'mapValues', 'regexContains', 'regexFind', 'regexFindAll', 'regexMatch', 'stringContains', 'stringIndexOf', 'stringRepeat', 'stringReplaceAll', 'stringReplaceOne', 'stringReverse', 'timestampAdd', 'timestampSubtract', 'timestampToUnixMicros', 'timestampToUnixMillis', 'timestampToUnixSeconds', 'timestampTruncate', 'trunc', 'type', 'unixMicrosToTimestamp', 'unixMillisToTimestamp', 'unixSecondsToTimestamp', 'vectorLength', 'xor', 'length'];
+function createNode(proto, node) {
+  const runtimeNode = Object.create(proto);
+  Object.assign(runtimeNode, node);
+  return runtimeNode;
+}
+function createExpressionProto() {
+  const proto = {
+    as(name) {
+      return createAliasedExpression(this, name);
+    },
+    ascending() {
+      return createOrdering(this, 'ascending');
+    },
+    descending() {
+      return createOrdering(this, 'descending');
+    }
+  };
+  for (const methodName of EXPRESSION_METHOD_NAMES) {
+    Object.defineProperty(proto, methodName, {
+      value(...args) {
+        return createMethodResult(methodName, this, args);
+      }
+    });
+  }
+  return proto;
+}
+const expressionProto = createExpressionProto();
+const aggregateProto = {
+  as(name) {
+    return createAliasedAggregate(this, name);
+  }
+};
+const orderingProto = {
+  ascending() {
+    return createOrdering(this.expr, 'ascending');
+  },
+  descending() {
+    return createOrdering(this.expr, 'descending');
+  }
+};
+function createField(path) {
+  return createNode(expressionProto, {
+    [RUNTIME_NODE_SYMBOL]: true,
+    __kind: 'expression',
+    exprType: 'Field',
+    selectable: true,
+    path: String(path ?? '')
+  });
+}
+function createConstant(value) {
+  return createNode(expressionProto, {
+    [RUNTIME_NODE_SYMBOL]: true,
+    __kind: 'expression',
+    exprType: 'Constant',
+    value
+  });
+}
+function normalizeMapLikeValue(value) {
+  const output = {};
+  for (const [key, entryValue] of Object.entries(value)) {
+    output[key] = normalizeRawValue(entryValue);
+  }
+  return output;
+}
+function normalizeRawValue(value) {
+  if (isRuntimeNode(value)) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    if (containsRuntimeNode(value)) {
+      return createFunctionExpression('array', value.map(entry => toExpressionArgument(entry)));
+    }
+    return value.map(normalizeRawValue);
+  }
+  if (isDocumentReferenceLike(value)) {
+    // Treat references as atomic values to avoid walking circular internal firestore graphs.
+    return value;
+  }
+  if (isRecord(value)) {
+    if (!isPlainObject(value)) {
+      return value;
+    }
+    return normalizeMapLikeValue(value);
+  }
+  return value;
+}
+function toExpressionArgument(value, fieldString = false) {
+  if (isRuntimeNode(value)) {
+    return value;
+  }
+  if (fieldString && typeof value === 'string') {
+    return createField(value);
+  }
+  if (Array.isArray(value) && containsRuntimeNode(value)) {
+    return createFunctionExpression('array', value.map(entry => toExpressionArgument(entry)));
+  }
+  return createConstant(normalizeRawValue(value));
+}
+function createFunctionExpression(name, args) {
+  return createNode(expressionProto, {
+    [RUNTIME_NODE_SYMBOL]: true,
+    __kind: 'expression',
+    exprType: 'Function',
+    selectable: true,
+    name,
+    args
+  });
+}
+function createBooleanExpression(name, args) {
+  return createNode(expressionProto, {
+    [RUNTIME_NODE_SYMBOL]: true,
+    __kind: 'expression',
+    exprType: 'Function',
+    selectable: true,
+    name,
+    args
+  });
+}
+function createAggregate(kind, args = []) {
+  return createNode(aggregateProto, {
+    [RUNTIME_NODE_SYMBOL]: true,
+    __kind: 'aggregate',
+    exprType: 'AggregateFunction',
+    kind,
+    args
+  });
+}
+function createAliasedExpression(expr, alias) {
+  return createNode(Object.prototype, {
+    [RUNTIME_NODE_SYMBOL]: true,
+    __kind: 'aliasedExpression',
+    exprType: 'AliasedExpression',
+    selectable: true,
+    expr,
+    alias
+  });
+}
+function createAliasedAggregate(aggregate, alias) {
+  return createNode(Object.prototype, {
+    [RUNTIME_NODE_SYMBOL]: true,
+    __kind: 'aliasedAggregate',
+    aggregate,
+    alias
+  });
+}
+function createOrdering(expr, direction) {
+  return createNode(orderingProto, {
+    [RUNTIME_NODE_SYMBOL]: true,
+    __kind: 'ordering',
+    expr,
+    direction
+  });
+}
+function normalizeGlobalArguments(name, args) {
+  const fieldIndexList = [];
+  switch (name) {
+    case 'add':
+    case 'subtract':
+    case 'divide':
+    case 'multiply':
+    case 'mod':
+    case 'pow':
+    case 'abs':
+    case 'ceil':
+    case 'floor':
+    case 'round':
+    case 'trunc':
+    case 'toLower':
+    case 'toUpper':
+    case 'trim':
+    case 'substring':
+    case 'arrayGet':
+    case 'arrayLength':
+    case 'arraySum':
+    case 'arrayConcat':
+    case 'byteLength':
+    case 'charLength':
+    case 'collectionId':
+    case 'exp':
+    case 'ln':
+    case 'log':
+    case 'log10':
+    case 'reverse':
+    case 'split':
+    case 'cosineDistance':
+    case 'dotProduct':
+    case 'euclideanDistance':
+    case 'isAbsent':
+    case 'isType':
+    case 'logicalMaximum':
+    case 'logicalMinimum':
+    case 'ltrim':
+    case 'rtrim':
+    case 'stringConcat':
+    case 'mapEntries':
+    case 'mapGet':
+    case 'mapKeys':
+    case 'mapMerge':
+    case 'mapRemove':
+    case 'mapSet':
+    case 'mapValues':
+    case 'regexContains':
+    case 'regexFind':
+    case 'regexFindAll':
+    case 'regexMatch':
+    case 'stringContains':
+    case 'stringIndexOf':
+    case 'stringRepeat':
+    case 'stringReplaceAll':
+    case 'stringReplaceOne':
+    case 'stringReverse':
+    case 'timestampAdd':
+    case 'timestampSubtract':
+    case 'timestampToUnixMicros':
+    case 'timestampToUnixMillis':
+    case 'timestampToUnixSeconds':
+    case 'timestampTruncate':
+    case 'type':
+    case 'unixMicrosToTimestamp':
+    case 'unixMillisToTimestamp':
+    case 'unixSecondsToTimestamp':
+    case 'vectorLength':
+    case 'length':
+    case 'startsWith':
+    case 'endsWith':
+    case 'like':
+    case 'equalAny':
+    case 'notEqualAny':
+      fieldIndexList.push(0);
+      break;
+    case 'gt':
+    case 'greaterThan':
+    case 'eq':
+    case 'equal':
+    case 'notEqual':
+    case 'gte':
+    case 'greaterThanOrEqual':
+    case 'lt':
+    case 'lessThan':
+    case 'lte':
+    case 'lessThanOrEqual':
+    case 'exists':
+    case 'arrayContains':
+    case 'arrayContainsAny':
+    case 'arrayContainsAll':
+    case 'sum':
+    case 'count':
+    case 'average':
+    case 'countDistinct':
+    case 'first':
+    case 'last':
+    case 'arrayAgg':
+    case 'arrayAggDistinct':
+    case 'maximum':
+    case 'minimum':
+      fieldIndexList.push(0);
+      break;
+    default:
+      break;
+  }
+  return args.map((arg, index) => toExpressionArgument(arg, fieldIndexList.includes(index)));
+}
+function createMethodResult(name, base, rawArgs) {
+  const canonicalName = toCanonicalFunctionName(name);
+  if (AGGREGATE_KINDS.has(canonicalName)) {
+    return createAggregate(canonicalName, [base, ...rawArgs.map(arg => toExpressionArgument(arg))]);
+  }
+  return createFunctionExpression(canonicalName, [base, ...rawArgs.map(arg => toExpressionArgument(arg))]);
+}
+function callBooleanHelper(name, argsLike) {
+  return createBooleanExpression(toCanonicalFunctionName(name), normalizeGlobalArguments(name, Array.from(argsLike)));
+}
+function callFunctionHelper(name, argsLike) {
+  return createFunctionExpression(toCanonicalFunctionName(name), normalizeGlobalArguments(name, Array.from(argsLike)));
+}
+function callAggregateHelper(name, argsLike) {
+  return createAggregate(toCanonicalFunctionName(name), normalizeGlobalArguments(name, Array.from(argsLike)));
+}
+function callExpressionHelper(name, argsLike) {
+  return createFunctionExpression(toCanonicalFunctionName(name), normalizeGlobalArguments(name, Array.from(argsLike)));
+}
+
+// --- Expression / helper stubs (for use in where, select, addFields, aggregate, sort, etc.) ---
+
+/**
+ * @beta
+ * Returns a Field reference for use in pipeline expressions.
+ */
+export function field(_path) {
+  return createField(_path);
+}
+
+/**
+ * @beta
+ * Logical AND of boolean expressions.
+ */
+export function and(first, second, ...more) {
+  void first;
+  void second;
+  void more;
+  return callBooleanHelper('and', arguments);
+}
+
+/**
+ * @beta
+ * Logical OR of boolean expressions.
+ */
+export function or(first, second, ...more) {
+  void first;
+  void second;
+  void more;
+  return callBooleanHelper('or', arguments);
+}
+
+/**
+ * @beta
+ * Greater-than comparison.
+ */
+export function gt(_left, _right) {
+  return callBooleanHelper('gt', arguments);
+}
+
+/**
+ * @beta
+ * Greater-than comparison (alias for gt).
+ */
+export function greaterThan(_left, _right) {
+  return callBooleanHelper('greaterThan', arguments);
+}
+
+/**
+ * @beta
+ * Equality comparison.
+ */
+export function eq(_left, _right) {
+  return callBooleanHelper('eq', arguments);
+}
+
+/**
+ * @beta
+ * Equality comparison (alias for eq).
+ */
+export function equal(_left, _right) {
+  return callBooleanHelper('equal', arguments);
+}
+
+/**
+ * @beta
+ * Inequality comparison.
+ */
+export function notEqual(_left, _right) {
+  return callBooleanHelper('notEqual', arguments);
+}
+
+/**
+ * @beta
+ * Greater-than-or-equal comparison.
+ */
+export function gte(_left, _right) {
+  return callBooleanHelper('gte', arguments);
+}
+
+/**
+ * @beta
+ * Less-than comparison.
+ */
+export function lt(_left, _right) {
+  return callBooleanHelper('lt', arguments);
+}
+
+/**
+ * @beta
+ * Less-than comparison (alias for lt).
+ */
+export function lessThan(_left, _right) {
+  return callBooleanHelper('lessThan', arguments);
+}
+
+/**
+ * @beta
+ * Less-than-or-equal comparison.
+ */
+export function lte(_left, _right) {
+  return callBooleanHelper('lte', arguments);
+}
+
+/**
+ * @beta
+ * Less-than-or-equal comparison (alias for lte).
+ */
+export function lessThanOrEqual(_left, _right) {
+  return callBooleanHelper('lessThanOrEqual', arguments);
+}
+
+/**
+ * @beta
+ * Greater-than-or-equal comparison (alias for gte).
+ */
+export function greaterThanOrEqual(_left, _right) {
+  return callBooleanHelper('greaterThanOrEqual', arguments);
+}
+
+/**
+ * @beta
+ * Checks if a field exists (or expression evaluates to a value).
+ */
+export function exists(_valueOrFieldName) {
+  return callBooleanHelper('exists', arguments);
+}
+
+/**
+ * @beta
+ * Checks if an array contains an element.
+ */
+export function arrayContains(_arrayOrFieldName, _element) {
+  return callBooleanHelper('arrayContains', arguments);
+}
+
+/**
+ * @beta
+ * Checks if an array contains any of the given values.
+ */
+export function arrayContainsAny(_arrayOrFieldName, _values) {
+  return callBooleanHelper('arrayContainsAny', arguments);
+}
+
+/**
+ * @beta
+ * Checks if an array contains all of the given values.
+ */
+export function arrayContainsAll(_arrayOrFieldName, _values) {
+  return callBooleanHelper('arrayContainsAll', arguments);
+}
+
+/**
+ * @beta
+ * Checks if a string starts with a prefix.
+ */
+
+export function startsWith(_stringOrFieldName, _prefix) {
+  return callBooleanHelper('startsWith', arguments);
+}
+
+/**
+ * @beta
+ * Checks if a string ends with a suffix.
+ */
+
+export function endsWith(_stringOrFieldName, _suffix) {
+  return callBooleanHelper('endsWith', arguments);
+}
+
+/**
+ * @beta
+ * Ordering helper (e.g. Ordering.of(field('rating')).descending()).
+ */
+export const OrderingHelper = {
+  of(_fieldOrOrdering) {
+    if (isOrderingNode(_fieldOrOrdering)) {
+      return _fieldOrOrdering;
+    }
+    return createOrdering(toExpressionArgument(_fieldOrOrdering, true), 'ascending');
+  }
+};
+
+/**
+ * @beta
+ * Ascending ordering (standalone). Use in sort().
+ */
+export function ascending(_expr) {
+  return createOrdering(toExpressionArgument(_expr, true), 'ascending');
+}
+
+/**
+ * @beta
+ * Descending ordering (standalone). Use in sort().
+ */
+export function descending(_expr) {
+  return createOrdering(toExpressionArgument(_expr, true), 'descending');
+}
+
+/**
+ * @beta
+ * Average aggregation (e.g. avg(field('rating')).as('avgRating')).
+ */
+export function avg(_f) {
+  return callAggregateHelper('avg', arguments);
+}
+
+/**
+ * @beta
+ * Count-all aggregation (e.g. countAll().as('total')).
+ */
+export function countAll() {
+  return createAggregate('countAll');
+}
+
+/**
+ * @beta
+ * Map expression for replaceWith etc.
+ */
+export function map(_entries) {
+  return createFunctionExpression('map', [toExpressionArgument(_entries)]);
+}
+
+/**
+ * @beta
+ * Array expression.
+ */
+export function array(_elements) {
+  return createFunctionExpression('array', _elements.map(entry => toExpressionArgument(entry)));
+}
+
+// --- Arithmetic / constant expression helpers (align with JS SDK) ---
+
+/**
+ * @beta
+ * Creates a constant expression for a number value.
+ */
+
+/**
+ * @beta
+ * Creates a constant expression for a string value.
+ */
+
+/**
+ * @beta
+ * Creates a constant boolean expression.
+ */
+
+/**
+ * @beta
+ * Creates a constant expression for null.
+ */
+
+/**
+ * @beta
+ * Creates a constant expression for a value (e.g. GeoPoint, Timestamp, Date, Bytes, DocumentReference, VectorValue).
+ */
+
+export function constant(_value) {
+  return createConstant(normalizeRawValue(_value));
+}
+
+/**
+ * @beta
+ * Creates an expression that adds two or more expressions together.
+ *
+ * @param first - The first expression to add.
+ * @param second - The second expression or literal to add.
+ * @returns A new Expression representing the addition operation.
+ */
+
+/**
+ * @beta
+ * Creates an expression that adds a field's value to an expression.
+ *
+ * @param fieldName - The name of the field containing the value to add.
+ * @param second - The second expression or literal to add.
+ * @returns A new Expression representing the addition operation.
+ */
+
+export function add(_first, _second) {
+  return callFunctionHelper('add', arguments);
+}
+
+/**
+ * @beta
+ * Creates an expression that subtracts the second from the first.
+ */
+
+/**
+ * @beta
+ * Creates an expression that subtracts a constant value from an expression.
+ */
+
+/**
+ * @beta
+ * Creates an expression that subtracts an expression from a field's value.
+ */
+
+/**
+ * @beta
+ * Creates an expression that subtracts a constant value from a field's value.
+ */
+
+export function subtract(_leftOrField, _rightOrValue) {
+  return callFunctionHelper('subtract', arguments);
+}
+
+// --- Additional arithmetic and aggregate helpers (align with JS SDK) ---
+
+/**
+ * @beta
+ * Creates an expression that divides the first by the second.
+ */
+
+/**
+ * @beta
+ * Creates an expression that divides an expression by a constant value.
+ */
+
+/**
+ * @beta
+ * Creates an expression that divides a field's value by an expression.
+ */
+
+/**
+ * @beta
+ * Creates an expression that divides a field's value by a constant.
+ */
+
+export function divide(_leftOrField, _rightOrValue) {
+  return callFunctionHelper('divide', arguments);
+}
+
+/**
+ * @beta
+ * Creates an expression that multiplies two or more expressions.
+ */
+
+/**
+ * @beta
+ * Creates an expression that multiplies a field's value by an expression or literal.
+ */
+
+export function multiply(_first, _second) {
+  return callFunctionHelper('multiply', arguments);
+}
+
+/**
+ * @beta
+ * Creates an expression that evaluates to the document ID (and optionally path).
+ *
+ * @param documentPath - Document path string or DocumentReference.
+ * @returns A new Expression representing the document ID.
+ */
+
+/**
+ * @beta
+ * Creates an expression that evaluates to the document ID from a path expression.
+ */
+
+export function documentId(_documentPath) {
+  return callFunctionHelper('documentId', arguments);
+}
+
+/**
+ * @beta
+ * Creates an aggregation that sums values from an expression across stage inputs.
+ */
+
+/**
+ * @beta
+ * Creates an aggregation that sums a field's values across stage inputs.
+ */
+
+export function sum(_exprOrField) {
+  return callAggregateHelper('sum', arguments);
+}
+
+/**
+ * @beta
+ * Creates an aggregation that counts stage inputs with valid evaluations of the expression.
+ */
+
+/**
+ * @beta
+ * Creates an aggregation that counts stage inputs where the field exists.
+ */
+
+export function count(_exprOrField) {
+  return callAggregateHelper('count', arguments);
+}
+
+/**
+ * @beta
+ * Creates an aggregation that calculates the average (mean) of values from an expression.
+ * SDK name: average (avg is RN alias).
+ */
+
+/**
+ * @beta
+ * Creates an aggregation that calculates the average (mean) of a field's values.
+ */
+
+export function average(_exprOrField) {
+  return callAggregateHelper('average', arguments);
+}
+
+// --- More expression and aggregate helpers (align with JS SDK) ---
+
+/**
+ * @beta
+ * Absolute value of a numeric expression.
+ */
+
+/**
+ * @beta
+ * Absolute value of a field.
+ */
+
+export function abs(_exprOrField) {
+  return callFunctionHelper('abs', arguments);
+}
+
+/**
+ * @beta
+ * Rounds up to the nearest integer.
+ */
+
+export function ceil(_exprOrField) {
+  return callFunctionHelper('ceil', arguments);
+}
+
+/**
+ * @beta
+ * Rounds down to the nearest integer.
+ */
+
+export function floor(_exprOrField) {
+  return callFunctionHelper('floor', arguments);
+}
+
+/**
+ * @beta
+ * Remainder (modulo) of left divided by right.
+ */
+
+export function mod(_leftOrField, _rightOrValue) {
+  return callFunctionHelper('mod', arguments);
+}
+
+/**
+ * @beta
+ * Rounds to the nearest integer (or to decimalPlaces when provided).
+ */
+
+/**
+ * @beta
+ * Rounds to the given number of decimal places.
+ */
+
+export function round(_exprOrField, _decimalPlaces) {
+  return callFunctionHelper('round', arguments);
+}
+
+/**
+ * @beta
+ * Conditional expression: if condition then thenExpr else elseExpr.
+ */
+export function conditional(_condition, _thenExpr, _elseExpr) {
+  return callFunctionHelper('conditional', arguments);
+}
+
+/**
+ * @beta
+ * Count distinct values of an expression or field.
+ */
+export function countDistinct(_expr) {
+  return callAggregateHelper('countDistinct', arguments);
+}
+
+/**
+ * @beta
+ * First value of the expression in each group (aggregate).
+ */
+
+export function first(_exprOrField) {
+  return callAggregateHelper('first', arguments);
+}
+
+/**
+ * @beta
+ * Last value of the expression in each group (aggregate).
+ */
+
+export function last(_exprOrField) {
+  return callAggregateHelper('last', arguments);
+}
+
+// --- arrayAgg, concat, sqrt, currentTimestamp, not, ifAbsent, ifError, string helpers ---
+
+/**
+ * @beta
+ * Collects all values of an expression across stage inputs into an array (aggregate).
+ */
+
+export function arrayAgg(_exprOrField) {
+  return callAggregateHelper('arrayAgg', arguments);
+}
+
+/**
+ * @beta
+ * Concatenates two or more expressions (e.g. strings or arrays).
+ */
+
+export function concat(_first, _second, ..._others) {
+  return callFunctionHelper('concat', arguments);
+}
+
+/**
+ * @beta
+ * Square root of a numeric expression.
+ */
+
+export function sqrt(_exprOrField) {
+  return callFunctionHelper('sqrt', arguments);
+}
+
+/**
+ * @beta
+ * Server timestamp at execution time.
+ */
+export function currentTimestamp() {
+  return callFunctionHelper('currentTimestamp', arguments);
+}
+
+/**
+ * @beta
+ * Logical NOT of a boolean expression.
+ */
+export function not(_booleanExpr) {
+  return callBooleanHelper('not', arguments);
+}
+
+/**
+ * @beta
+ * If ifExpr is present use it, else use elseExpr/elseValue.
+ */
+
+export function ifAbsent(_ifExpr, _elseValue) {
+  return callExpressionHelper('ifAbsent', arguments);
+}
+
+/**
+ * @beta
+ * If tryExpr errors, return catchExpr/catchValue (error handling expression).
+ */
+
+export function ifError(_tryExpr, _catch) {
+  return callFunctionHelper('ifError', arguments);
+}
+
+/**
+ * @beta
+ * Converts string to lower case.
+ */
+
+export function toLower(_fieldOrExpr) {
+  return callFunctionHelper('toLower', arguments);
+}
+
+/**
+ * @beta
+ * Converts string to upper case.
+ */
+
+export function toUpper(_fieldOrExpr) {
+  return callFunctionHelper('toUpper', arguments);
+}
+
+/**
+ * @beta
+ * Trims whitespace (or optional valueToTrim) from string.
+ */
+
+export function trim(_fieldOrExpr, _valueToTrim) {
+  return callFunctionHelper('trim', arguments);
+}
+
+/**
+ * @beta
+ * Substring from position with optional length.
+ */
+
+export function substring(_fieldOrInput, _position, _length) {
+  return callFunctionHelper('substring', arguments);
+}
+
+// --- Array expression helpers (align with JS SDK) ---
+
+/**
+ * @beta
+ * Collects distinct values of an expression across stage inputs into an array (aggregate).
+ */
+
+export function arrayAggDistinct(_exprOrField) {
+  return callAggregateHelper('arrayAggDistinct', arguments);
+}
+
+/**
+ * @beta
+ * Concatenates two or more arrays.
+ */
+
+export function arrayConcat(_first, _second, ..._others) {
+  return callFunctionHelper('arrayConcat', arguments);
+}
+
+/**
+ * @beta
+ * Gets element at offset in an array field or expression.
+ */
+
+export function arrayGet(_arrayOrField, _offset) {
+  return callFunctionHelper('arrayGet', arguments);
+}
+
+/**
+ * @beta
+ * Length of an array (field or expression).
+ */
+
+export function arrayLength(_fieldOrExpr) {
+  return callFunctionHelper('arrayLength', arguments);
+}
+
+/**
+ * @beta
+ * Sum of numeric values in an array (aggregate-like for arrays).
+ */
+
+export function arraySum(_fieldOrExpr) {
+  return callFunctionHelper('arraySum', arguments);
+}
+
+// --- Batch: byteLength, charLength, collectionId, countIf, exp, join, like, ln, log, log10, maximum, minimum, pow, reverse, split ---
+
+export function byteLength(_exprOrField) {
+  return callFunctionHelper('byteLength', arguments);
+}
+export function charLength(_fieldOrExpr) {
+  return callFunctionHelper('charLength', arguments);
+}
+export function collectionId(_fieldOrExpr) {
+  return callFunctionHelper('collectionId', arguments);
+}
+export function countIf(_booleanExpr) {
+  return callAggregateHelper('countIf', arguments);
+}
+export function exp(_exprOrField) {
+  return callFunctionHelper('exp', arguments);
+}
+export function join(_arrayOrField, _delimiter) {
+  return callExpressionHelper('join', arguments);
+}
+export function like(_fieldOrExpr, _pattern) {
+  return callBooleanHelper('like', arguments);
+}
+export function ln(_fieldOrExpr) {
+  return callFunctionHelper('ln', arguments);
+}
+export function log(_exprOrField, _base) {
+  return callFunctionHelper('log', arguments);
+}
+export function log10(_fieldOrExpr) {
+  return callFunctionHelper('log10', arguments);
+}
+export function maximum(_exprOrField) {
+  return callAggregateHelper('maximum', arguments);
+}
+export function minimum(_exprOrField) {
+  return callAggregateHelper('minimum', arguments);
+}
+export function pow(_base, _exponent) {
+  return callFunctionHelper('pow', arguments);
+}
+export function reverse(_exprOrField) {
+  return callFunctionHelper('reverse', arguments);
+}
+export function split(_fieldOrExpr, _delimiter) {
+  return callFunctionHelper('split', arguments);
+}
+
+// --- Batch 2: cosineDistance, dotProduct, equalAny, euclideanDistance, isAbsent, isError, isType, logicalMaximum, logicalMinimum, ltrim, notEqualAny, rand, rtrim, stringConcat ---
+
+export function cosineDistance(_fieldOrExpr, _vectorOrExpr) {
+  return callFunctionHelper('cosineDistance', arguments);
+}
+export function dotProduct(_fieldOrExpr, _vectorOrExpr) {
+  return callFunctionHelper('dotProduct', arguments);
+}
+export function equalAny(_exprOrField, _valuesOrArray) {
+  return callBooleanHelper('equalAny', arguments);
+}
+export function euclideanDistance(_fieldOrExpr, _vectorOrExpr) {
+  return callFunctionHelper('euclideanDistance', arguments);
+}
+export function isAbsent(_valueOrField) {
+  return callBooleanHelper('isAbsent', arguments);
+}
+export function isError(_value) {
+  return callBooleanHelper('isError', arguments);
+}
+export function isType(_fieldOrExpr, _type) {
+  return callBooleanHelper('isType', arguments);
+}
+export function logicalMaximum(_first, _second, ..._others) {
+  return callFunctionHelper('logicalMaximum', arguments);
+}
+export function logicalMinimum(_first, _second, ..._others) {
+  return callFunctionHelper('logicalMinimum', arguments);
+}
+export function ltrim(_fieldOrExpr, _valueToTrim) {
+  return callFunctionHelper('ltrim', arguments);
+}
+export function notEqualAny(_elemOrField, _valuesOrArray) {
+  return callBooleanHelper('notEqualAny', arguments);
+}
+export function rand() {
+  return callFunctionHelper('rand', arguments);
+}
+export function rtrim(_fieldOrExpr, _valueToTrim) {
+  return callFunctionHelper('rtrim', arguments);
+}
+export function stringConcat(_first, _second, ..._others) {
+  return callFunctionHelper('stringConcat', arguments);
+}
+
+// --- Batch 3: map*, regex*, stringContains, stringIndexOf, stringRepeat, stringReplaceAll ---
+
+export function mapEntries(_mapOrExpr) {
+  return callFunctionHelper('mapEntries', arguments);
+}
+export function mapGet(_mapOrExpr, _subField) {
+  return callFunctionHelper('mapGet', arguments);
+}
+export function mapKeys(_mapOrExpr) {
+  return callFunctionHelper('mapKeys', arguments);
+}
+export function mapMerge(_first, _second, ..._others) {
+  return callFunctionHelper('mapMerge', arguments);
+}
+export function mapRemove(_mapOrExpr, _keyOrExpr) {
+  return callFunctionHelper('mapRemove', arguments);
+}
+export function mapSet(_mapOrExpr, _key, _value, ..._more) {
+  return callFunctionHelper('mapSet', arguments);
+}
+export function mapValues(_mapOrExpr) {
+  return callFunctionHelper('mapValues', arguments);
+}
+export function regexContains(_fieldOrExpr, _pattern) {
+  return callBooleanHelper('regexContains', arguments);
+}
+export function regexFind(_fieldOrExpr, _pattern) {
+  return callFunctionHelper('regexFind', arguments);
+}
+export function regexFindAll(_fieldOrExpr, _pattern) {
+  return callFunctionHelper('regexFindAll', arguments);
+}
+export function regexMatch(_fieldOrExpr, _pattern) {
+  return callBooleanHelper('regexMatch', arguments);
+}
+export function stringContains(_fieldOrExpr, _substring) {
+  return callBooleanHelper('stringContains', arguments);
+}
+export function stringIndexOf(_fieldOrExpr, _search) {
+  return callFunctionHelper('stringIndexOf', arguments);
+}
+export function stringRepeat(_fieldOrExpr, _repetitions) {
+  return callFunctionHelper('stringRepeat', arguments);
+}
+export function stringReplaceAll(_fieldOrExpr, _find, _replacement) {
+  return callFunctionHelper('stringReplaceAll', arguments);
+}
+
+// --- Batch 4: stringReplaceOne, stringReverse, timestamp*, trunc, type, unix*ToTimestamp, vectorLength, xor ---
+
+export function stringReplaceOne(_fieldOrExpr, _find, _replacement) {
+  return callFunctionHelper('stringReplaceOne', arguments);
+}
+export function stringReverse(_exprOrField) {
+  return callFunctionHelper('stringReverse', arguments);
+}
+export function timestampAdd(_tsOrField, _unit, _amount) {
+  return callFunctionHelper('timestampAdd', arguments);
+}
+export function timestampSubtract(_tsOrField, _unit, _amount) {
+  return callFunctionHelper('timestampSubtract', arguments);
+}
+export function timestampToUnixMicros(_exprOrField) {
+  return callFunctionHelper('timestampToUnixMicros', arguments);
+}
+export function timestampToUnixMillis(_exprOrField) {
+  return callFunctionHelper('timestampToUnixMillis', arguments);
+}
+export function timestampToUnixSeconds(_exprOrField) {
+  return callFunctionHelper('timestampToUnixSeconds', arguments);
+}
+export function timestampTruncate(_fieldOrExpr, _granularity, _timezone) {
+  return callFunctionHelper('timestampTruncate', arguments);
+}
+export function trunc(_fieldOrExpr, _decimalPlaces) {
+  return callFunctionHelper('trunc', arguments);
+}
+export function type(_fieldOrExpr) {
+  return callFunctionHelper('type', arguments);
+}
+export function unixMicrosToTimestamp(_exprOrField) {
+  return callFunctionHelper('unixMicrosToTimestamp', arguments);
+}
+export function unixMillisToTimestamp(_exprOrField) {
+  return callFunctionHelper('unixMillisToTimestamp', arguments);
+}
+export function unixSecondsToTimestamp(_exprOrField) {
+  return callFunctionHelper('unixSecondsToTimestamp', arguments);
+}
+export function vectorLength(_exprOrField) {
+  return callFunctionHelper('vectorLength', arguments);
+}
+export function xor(_first, _second, ..._additionalConditions) {
+  return callBooleanHelper('xor', arguments);
+}
+
+/**
+ * @beta
+ * Length of string, array, map, vector, or bytes (field or expression).
+ */
+
+export function length(_fieldOrExpr) {
+  return callFunctionHelper('length', arguments);
+}
+//# sourceMappingURL=expressions.js.map