From 89381aa6b708a718be6722b47a8165ad7e9635b2 Mon Sep 17 00:00:00 2001 From: wu-hui Date: Fri, 15 May 2026 08:37:47 -0400 Subject: [PATCH 1/2] feat(firestore): Add assetDocsDir output tracking to GenerateApiTxtTask to ensure reliable incremental asset generation --- .gitignore | 5 +- .../src/main/assets/expressions.docs.txt | 19833 ++++++++++++++++ .../src/main/assets/pipeline.docs.txt | 1294 + .../firebase/gradle/plugins/Metalava.kt | 86 +- 4 files changed, 21214 insertions(+), 4 deletions(-) create mode 100644 firebase-firestore/src/main/assets/expressions.docs.txt create mode 100644 firebase-firestore/src/main/assets/pipeline.docs.txt diff --git a/.gitignore b/.gitignore index 13b37b5e60a..74a0bac6f3a 100644 --- a/.gitignore +++ b/.gitignore @@ -24,4 +24,7 @@ vertexai-sdk-test-data/ firebase-appdistribution-gradle/service-credentials.json # Ignore generated credentials from google-github-actions/auth -gha-creds-*.json \ No newline at end of file +gha-creds-*.json + +# Jetski CLI artifacts +.jetskicli/ \ No newline at end of file diff --git a/firebase-firestore/src/main/assets/expressions.docs.txt b/firebase-firestore/src/main/assets/expressions.docs.txt new file mode 100644 index 00000000000..fc8770df5bd --- /dev/null +++ b/firebase-firestore/src/main/assets/expressions.docs.txt @@ -0,0 +1,19833 @@ +// File: AggregateFunction.java +// Copyright 2025 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file 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. +package com.google.firebase.firestore.pipeline; + + +/** A class that represents an aggregate function. */ + +@SuppressWarnings({"unchecked", "deprecation", "all"}) +public final class AggregateFunction { + +AggregateFunction() { throw new RuntimeException("Stub!"); } + +/** + * Assigns an alias to this aggregate. + * + * @param alias The alias to assign to this aggregate. + * @return A new [AliasedAggregate] that wraps this aggregate and associates it with the provided + * alias. + */ + +public com.google.firebase.firestore.pipeline.AliasedAggregate alias(java.lang.String alias) { throw new RuntimeException("Stub!"); } + +/** + * Creates a raw aggregation function. + * + * This method provides a way to call aggregation functions that are supported by the Firestore + * backend but that are not available as specific factory methods in this class. + * + * @param name The name of the aggregation function. + * @param expr The expressions to pass as arguments to the function. + * @return A new [AggregateFunction] for the specified function. + */ + +public static com.google.firebase.firestore.pipeline.AggregateFunction rawAggregate(java.lang.String name, com.google.firebase.firestore.pipeline.Expression... expr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that counts the total number of stage inputs. + * + * @return A new [AggregateFunction] representing the countAll aggregation. + */ + +public static com.google.firebase.firestore.pipeline.AggregateFunction countAll() { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that counts the number of stage inputs where the input field exists. + * + * @param fieldName The name of the field to count. + * @return A new [AggregateFunction] representing the 'count' aggregation. + */ + +public static com.google.firebase.firestore.pipeline.AggregateFunction count(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that counts the number of stage inputs with valid evaluations of the + * provided [expression]. + * + * @param expression The expression to count. + * @return A new [AggregateFunction] representing the 'count' aggregation. + */ + +public static com.google.firebase.firestore.pipeline.AggregateFunction count(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that counts the number of stage inputs where the provided boolean + * expression evaluates to true. + * + * @param condition The boolean expression to evaluate on each input. + * @return A new [AggregateFunction] representing the count aggregation. + */ + +public static com.google.firebase.firestore.pipeline.AggregateFunction countIf(com.google.firebase.firestore.pipeline.BooleanExpression condition) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that calculates the sum of a field's values across multiple stage + * inputs. + * + * @param fieldName The name of the field containing numeric values to sum up. + * @return A new [AggregateFunction] representing the sum aggregation. + */ + +public static com.google.firebase.firestore.pipeline.AggregateFunction sum(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that calculates the sum of values from an expression across multiple + * stage inputs. + * + * @param expression The expression to sum up. + * @return A new [AggregateFunction] representing the sum aggregation. + */ + +public static com.google.firebase.firestore.pipeline.AggregateFunction sum(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that calculates the average (mean) of a field's values across multiple + * stage inputs. + * + * @param fieldName The name of the field containing numeric values to average. + * @return A new [AggregateFunction] representing the average aggregation. + */ + +public static com.google.firebase.firestore.pipeline.AggregateFunction average(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that calculates the average (mean) of values from an expression across + * multiple stage inputs. + * + * @param expression The expression representing the values to average. + * @return A new [AggregateFunction] representing the average aggregation. + */ + +public static com.google.firebase.firestore.pipeline.AggregateFunction average(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that finds the minimum value of a field across multiple stage inputs. + * + * @param fieldName The name of the field to find the minimum value of. + * @return A new [AggregateFunction] representing the minimum aggregation. + */ + +public static com.google.firebase.firestore.pipeline.AggregateFunction minimum(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that finds the minimum value of an expression across multiple stage + * inputs. + * + * @param expression The expression to find the minimum value of. + * @return A new [AggregateFunction] representing the minimum aggregation. + */ + +public static com.google.firebase.firestore.pipeline.AggregateFunction minimum(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that finds the maximum value of a field across multiple stage inputs. + * + * @param fieldName The name of the field to find the maximum value of. + * @return A new [AggregateFunction] representing the maximum aggregation. + */ + +public static com.google.firebase.firestore.pipeline.AggregateFunction maximum(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that finds the maximum value of an expression across multiple stage + * inputs. + * + * @param expression The expression to find the maximum value of. + * @return A new [AggregateFunction] representing the maximum aggregation. + */ + +public static com.google.firebase.firestore.pipeline.AggregateFunction maximum(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that counts the number of distinct values of a field across multiple + * stage inputs. + * + * @param fieldName The name of the field to count the distinct values of. + * @return A new [AggregateFunction] representing the count distinct aggregation. + */ + +public static com.google.firebase.firestore.pipeline.AggregateFunction countDistinct(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that counts the number of distinct values of an expression across + * multiple stage inputs. + * + * @param expression The expression to count the distinct values of. + * @return A new [AggregateFunction] representing the count distinct aggregation. + */ + +public static com.google.firebase.firestore.pipeline.AggregateFunction countDistinct(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that finds the first value of a field across multiple stage inputs. + * + * @param fieldName The name of the field to find the first value of. + * @return A new [AggregateFunction] representing the first aggregation. + */ + +public static com.google.firebase.firestore.pipeline.AggregateFunction first(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that finds the first value of an expression across multiple stage + * inputs. + * + * @param expression The expression to find the first value of. + * @return A new [AggregateFunction] representing the first aggregation. + */ + +public static com.google.firebase.firestore.pipeline.AggregateFunction first(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that finds the last value of a field across multiple stage inputs. + * + * @param fieldName The name of the field to find the last value of. + * @return A new [AggregateFunction] representing the last aggregation. + */ + +public static com.google.firebase.firestore.pipeline.AggregateFunction last(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that finds the last value of an expression across multiple stage + * inputs. + * + * @param expression The expression to find the last value of. + * @return A new [AggregateFunction] representing the last aggregation. + */ + +public static com.google.firebase.firestore.pipeline.AggregateFunction last(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that collects all values of a field across multiple stage inputs into + * an array. + * + * If the expression resolves to an absent value, it is converted to `null`. The order of + * elements in the output array is not stable and shouldn't be relied upon. + * + * @param fieldName The name of the field to collect values from. + * @return A new [AggregateFunction] representing the array_agg aggregation. + */ + +public static com.google.firebase.firestore.pipeline.AggregateFunction arrayAgg(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that collects all values of an expression across multiple stage inputs + * into an array. + * + * If the expression resolves to an absent value, it is converted to `null`. The order of + * elements in the output array is not stable and shouldn't be relied upon. + * + * @param expression The expression to collect values from. + * @return A new [AggregateFunction] representing the array_agg aggregation. + */ + +public static com.google.firebase.firestore.pipeline.AggregateFunction arrayAgg(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that collects all distinct values of a field across multiple stage + * inputs into an array. + * + * If the expression resolves to an absent value, it is converted to `null`. The order of + * elements in the output array is not stable and shouldn't be relied upon. + * + * @param fieldName The name of the field to collect values from. + * @return A new [AggregateFunction] representing the array_agg_distinct aggregation. + */ + +public static com.google.firebase.firestore.pipeline.AggregateFunction arrayAggDistinct(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that collects all distinct values of an expression across multiple + * stage inputs into an array. + * + * If the expression resolves to an absent value, it is converted to `null`. The order of + * elements in the output array is not stable and shouldn't be relied upon. + * + * @param expression The expression to collect values from. + * @return A new [AggregateFunction] representing the array_agg_distinct aggregation. + */ + +public static com.google.firebase.firestore.pipeline.AggregateFunction arrayAggDistinct(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } + +public static final com.google.firebase.firestore.pipeline.AggregateFunction.Companion Companion; +static { Companion = null; } +@SuppressWarnings({"unchecked", "deprecation", "all"}) +public static final class Companion { + +Companion() { throw new RuntimeException("Stub!"); } + +/** + * Creates a raw aggregation function. + * + * This method provides a way to call aggregation functions that are supported by the Firestore + * backend but that are not available as specific factory methods in this class. + * + * @param name The name of the aggregation function. + * @param expr The expressions to pass as arguments to the function. + * @return A new [AggregateFunction] for the specified function. + */ + +public com.google.firebase.firestore.pipeline.AggregateFunction rawAggregate(java.lang.String name, com.google.firebase.firestore.pipeline.Expression... expr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that counts the total number of stage inputs. + * + * @return A new [AggregateFunction] representing the countAll aggregation. + */ + +public com.google.firebase.firestore.pipeline.AggregateFunction countAll() { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that counts the number of stage inputs where the input field exists. + * + * @param fieldName The name of the field to count. + * @return A new [AggregateFunction] representing the 'count' aggregation. + */ + +public com.google.firebase.firestore.pipeline.AggregateFunction count(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that counts the number of stage inputs with valid evaluations of the + * provided [expression]. + * + * @param expression The expression to count. + * @return A new [AggregateFunction] representing the 'count' aggregation. + */ + +public com.google.firebase.firestore.pipeline.AggregateFunction count(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that counts the number of stage inputs where the provided boolean + * expression evaluates to true. + * + * @param condition The boolean expression to evaluate on each input. + * @return A new [AggregateFunction] representing the count aggregation. + */ + +public com.google.firebase.firestore.pipeline.AggregateFunction countIf(com.google.firebase.firestore.pipeline.BooleanExpression condition) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that calculates the sum of a field's values across multiple stage + * inputs. + * + * @param fieldName The name of the field containing numeric values to sum up. + * @return A new [AggregateFunction] representing the sum aggregation. + */ + +public com.google.firebase.firestore.pipeline.AggregateFunction sum(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that calculates the sum of values from an expression across multiple + * stage inputs. + * + * @param expression The expression to sum up. + * @return A new [AggregateFunction] representing the sum aggregation. + */ + +public com.google.firebase.firestore.pipeline.AggregateFunction sum(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that calculates the average (mean) of a field's values across multiple + * stage inputs. + * + * @param fieldName The name of the field containing numeric values to average. + * @return A new [AggregateFunction] representing the average aggregation. + */ + +public com.google.firebase.firestore.pipeline.AggregateFunction average(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that calculates the average (mean) of values from an expression across + * multiple stage inputs. + * + * @param expression The expression representing the values to average. + * @return A new [AggregateFunction] representing the average aggregation. + */ + +public com.google.firebase.firestore.pipeline.AggregateFunction average(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that finds the minimum value of a field across multiple stage inputs. + * + * @param fieldName The name of the field to find the minimum value of. + * @return A new [AggregateFunction] representing the minimum aggregation. + */ + +public com.google.firebase.firestore.pipeline.AggregateFunction minimum(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that finds the minimum value of an expression across multiple stage + * inputs. + * + * @param expression The expression to find the minimum value of. + * @return A new [AggregateFunction] representing the minimum aggregation. + */ + +public com.google.firebase.firestore.pipeline.AggregateFunction minimum(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that finds the maximum value of a field across multiple stage inputs. + * + * @param fieldName The name of the field to find the maximum value of. + * @return A new [AggregateFunction] representing the maximum aggregation. + */ + +public com.google.firebase.firestore.pipeline.AggregateFunction maximum(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that finds the maximum value of an expression across multiple stage + * inputs. + * + * @param expression The expression to find the maximum value of. + * @return A new [AggregateFunction] representing the maximum aggregation. + */ + +public com.google.firebase.firestore.pipeline.AggregateFunction maximum(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that counts the number of distinct values of a field across multiple + * stage inputs. + * + * @param fieldName The name of the field to count the distinct values of. + * @return A new [AggregateFunction] representing the count distinct aggregation. + */ + +public com.google.firebase.firestore.pipeline.AggregateFunction countDistinct(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that counts the number of distinct values of an expression across + * multiple stage inputs. + * + * @param expression The expression to count the distinct values of. + * @return A new [AggregateFunction] representing the count distinct aggregation. + */ + +public com.google.firebase.firestore.pipeline.AggregateFunction countDistinct(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that finds the first value of a field across multiple stage inputs. + * + * @param fieldName The name of the field to find the first value of. + * @return A new [AggregateFunction] representing the first aggregation. + */ + +public com.google.firebase.firestore.pipeline.AggregateFunction first(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that finds the first value of an expression across multiple stage + * inputs. + * + * @param expression The expression to find the first value of. + * @return A new [AggregateFunction] representing the first aggregation. + */ + +public com.google.firebase.firestore.pipeline.AggregateFunction first(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that finds the last value of a field across multiple stage inputs. + * + * @param fieldName The name of the field to find the last value of. + * @return A new [AggregateFunction] representing the last aggregation. + */ + +public com.google.firebase.firestore.pipeline.AggregateFunction last(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that finds the last value of an expression across multiple stage + * inputs. + * + * @param expression The expression to find the last value of. + * @return A new [AggregateFunction] representing the last aggregation. + */ + +public com.google.firebase.firestore.pipeline.AggregateFunction last(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that collects all values of a field across multiple stage inputs into + * an array. + * + * If the expression resolves to an absent value, it is converted to `null`. The order of + * elements in the output array is not stable and shouldn't be relied upon. + * + * @param fieldName The name of the field to collect values from. + * @return A new [AggregateFunction] representing the array_agg aggregation. + */ + +public com.google.firebase.firestore.pipeline.AggregateFunction arrayAgg(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that collects all values of an expression across multiple stage inputs + * into an array. + * + * If the expression resolves to an absent value, it is converted to `null`. The order of + * elements in the output array is not stable and shouldn't be relied upon. + * + * @param expression The expression to collect values from. + * @return A new [AggregateFunction] representing the array_agg aggregation. + */ + +public com.google.firebase.firestore.pipeline.AggregateFunction arrayAgg(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that collects all distinct values of a field across multiple stage + * inputs into an array. + * + * If the expression resolves to an absent value, it is converted to `null`. The order of + * elements in the output array is not stable and shouldn't be relied upon. + * + * @param fieldName The name of the field to collect values from. + * @return A new [AggregateFunction] representing the array_agg_distinct aggregation. + */ + +public com.google.firebase.firestore.pipeline.AggregateFunction arrayAggDistinct(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that collects all distinct values of an expression across multiple + * stage inputs into an array. + * + * If the expression resolves to an absent value, it is converted to `null`. The order of + * elements in the output array is not stable and shouldn't be relied upon. + * + * @param expression The expression to collect values from. + * @return A new [AggregateFunction] representing the array_agg_distinct aggregation. + */ + +public com.google.firebase.firestore.pipeline.AggregateFunction arrayAggDistinct(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } +} + +} + + + +// File: AliasedAggregate.java +// Copyright 2025 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file 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. +package com.google.firebase.firestore.pipeline; + + +@SuppressWarnings({"unchecked", "deprecation", "all"}) +public final class AliasedAggregate { + +AliasedAggregate() { throw new RuntimeException("Stub!"); } +} + + + +// File: AliasedExpression.java +// Copyright 2025 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file 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. +// Ensure this overload exists or is correctly placed +// /** +// * Perform a full-text search on the specified field. +// * +// * Note: This Expression can only be used within a `Search` stage. +// * +// * @example +// * ```kotlin +// * db.pipeline().collection("restaurants").search( +// * SearchStage(query = matches("menu", "waffles")) +// * ) +// * ``` +// * +// * @param fieldName Perform search on this field. +// * @param rquery Define the search query using the search DSL. +// */ +// // TODO(search) this is internal until supported by the backend +// @Beta +// @JvmStatic +// internal fun matches(fieldName: String, rquery: String): BooleanExpression = +// matches(field(fieldName), rquery) +// +// /** +// * Perform a full-text search on the specified field. +// * +// * Note: This Expression can only be used within a `Search` stage. +// * +// * @example +// * ```kotlin +// * db.pipeline().collection("restaurants").search( +// * SearchStage(query = matches(field("menu"), "waffles")) +// * ) +// * ``` +// * +// * @param field Perform search on this field. +// * @param rquery Define the search query using the search DSL. +// */ +// // TODO(search) this is internal until supported by the backend +// @Beta +// @JvmStatic +// internal fun matches(field: Field, rquery: String): BooleanExpression = +// BooleanFunctionExpression("matches", notImplemented, field, constant(rquery)) +// /** +// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search +// query +// * in `bold`. +// * +// * This Expression can only be used within a `Search` stage. +// * +// * @example +// * ```kotlin +// * db.pipeline().collection("restaurants").search( +// * SearchStage(query = documentMatches("waffles"), addFields = arrayOf(snippet("menu", +// "waffles").alias("snippet"))) +// * ) +// * ``` +// * +// * @param fieldName Search the specified field for matching terms. +// * @param rquery Define the search query using the search DSL. +// */ +// @Beta +// @JvmStatic +// fun snippet(fieldName: String, rquery: String): Expression = +// FunctionExpression("snippet", notImplemented, field(fieldName), constant(rquery)) +// /** +// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search +// query +// * in `bold`. +// * +// * This Expression can only be used within a `Search` stage. +// * +// * @param fieldName Search the specified field for matching terms. +// * @param options Define how the snippet is generated. +// */ +// // TODO(search) snippet with options is internal and unimplemented until supported by the +// // backend +// @Beta +// @JvmStatic +// internal fun snippet(fieldName: String, options: SnippetOptions): Expression { +// throw NotImplementedError("Not implemented") +// } +// /** +// * Evaluates if the value in the field specified by `fieldName` is between the evaluated +// values +// * for `lowerBound` (inclusive) and `upperBound` (inclusive). +// * +// * @param fieldName Determine if this field is between two bounds. +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// */ +// // TODO(search) between is internal and unimplemented until supported by the backend +// @JvmStatic +// internal fun between( +// fieldName: String, +// lowerBound: Expression, +// upperBound: Expression +// ): BooleanExpression = +// BooleanFunctionExpression("between", notImplemented, fieldName, lowerBound, upperBound) +// /** +// * Evaluates if the value in the field specified by `fieldName` is between the values for +// * `lowerBound` (inclusive) and `upperBound` (inclusive). +// * +// * @param fieldName Determine if this field is between two bounds. +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// */ +// @JvmStatic +// internal fun between(fieldName: String, lowerBound: Any, upperBound: Any): +// BooleanExpression = +// between(fieldName, toExprOrConstant(lowerBound), toExprOrConstant(upperBound)) +// /** +// * Evaluates if the result of the specified `expression` is between the results of +// `lowerBound` +// * (inclusive) and `upperBound` (inclusive). +// * +// * @param expression Determine if the result of this expression is between two bounds. +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// */ +// @JvmStatic +// internal fun between( +// expression: Expression, +// lowerBound: Expression, +// upperBound: Expression +// ): BooleanExpression = +// BooleanFunctionExpression("between", notImplemented, expression, lowerBound, upperBound) +// /** +// * Evaluates if the result of the specified `expression` is between the `lowerBound` +// (inclusive) +// * and `upperBound` (inclusive). +// * +// * @param expression Determine if the result of this expression is between two bounds. +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// */ +// @JvmStatic +// internal fun between( +// expression: Expression, +// lowerBound: Any, +// upperBound: Any +// ): BooleanExpression = +// between(expression, toExprOrConstant(lowerBound), toExprOrConstant(upperBound)) +// // TODO(search) SnippetOptions is internal until supported by the backend +// @Beta +// internal class SnippetOptions private constructor(options: InternalOptions) : +// AbstractOptions(options) { +// /** Creates a new, empty `SnippetOptions` object. */ +// constructor(rquery: String) : this(InternalOptions.EMPTY.with("query", encodeValue(rquery))) +// +// fun withMaxSnippetWidth(max: Int): SnippetOptions { +// return with("max_snippet_width", encodeValue(max)) +// } +// +// fun withMaxSnippets(max: Int): SnippetOptions { +// return with("max_snippets", encodeValue(max)) +// } +// +// fun withSeparator(separator: String): SnippetOptions { +// return with("separator", encodeValue(separator)) +// } +// +// internal override fun self(options: InternalOptions): SnippetOptions { +// return SnippetOptions(options) +// } +// } +// /** +// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search query +// in +// * `bold`. +// * +// * Note: This Expression can only be used within a `Search` stage. +// * +// * @param rquery Define the search query using the search DTS. +// */ +// @Beta +// fun snippet(rquery: String): Expression = +// FunctionExpression( +// "snippet", +// notImplemented, +// arrayOf(this, constant(rquery)), +// SnippetOptions(rquery).options +// ) +// +// /** +// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search query +// in +// * `bold`. +// * +// * Note: This Expression can only be used within a `Search` stage. +// * +// * @param options Define how the snippet is generated. +// * +// * TODO(search) implement snippet with SnippetOptions - out of scope for first release +// */ +// @Beta +// internal fun snippet(options: SnippetOptions): Expression { +// throw NotImplementedError() +// } +// +// /** +// * Evaluates if the result of this `expression` is between the `lowerBound` (inclusive) and +// * `upperBound` (inclusive). +// * +// * @example +// * ``` +// * // Evaluate if the 'tireWidth' is between 2.2 and 2.4 +// * field('tireWidth').between(constant(2.2), constant(2.4)) +// * +// * // This is functionally equivalent to +// * and( +// * field('tireWidth').greaterThanOrEqual(constant(2.2)), +// * field('tireWidth').lessThanOrEqual(constant(2.4))) +// * ``` +// * +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// * +// * TODO(search) publish between - out of scope for first release +// */ +// internal fun between(lowerBound: Expression, upperBound: Expression): BooleanExpression = +// Companion.between(this, lowerBound, upperBound) +// +// /** +// * Evaluates if the result of this `expression` is between the `lowerBound` (inclusive) and +// * `upperBound` (inclusive). +// * +// * @example +// * ``` +// * // Evaluate if the 'tireWidth' is between 2.2 and 2.4 +// * field('tireWidth').between(2.2, 2.4) +// * +// * // This is functionally equivalent to +// * and( +// * field('tireWidth').greaterThanOrEqual(2.2), +// * field('tireWidth').lessThanOrEqual(2.4)) +// * ``` +// * +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// * +// * TODO(search) publish between - out of scope for first release +// */ +// internal fun between(lowerBound: Any, upperBound: Any): BooleanExpression = +// Companion.between(this, lowerBound, upperBound) +// +// This block runs only if fieldValue is not null. +// This value is used if getField() returns null. +// /** +// * Perform a full-text search on this field. +// * +// * Note: This Expression can only be used within a `Search` stage. +// * +// * @param rquery Define the search query using the rquery DTS. +// */ +// @Beta internal fun matches(rquery: String): BooleanExpression = matches(this, rquery) +package com.google.firebase.firestore.pipeline; + + +/** Represents an expression that will be given the alias in the output document. */ + +@SuppressWarnings({"unchecked", "deprecation", "all"}) +public final class AliasedExpression extends com.google.firebase.firestore.pipeline.Selectable { + +AliasedExpression() { throw new RuntimeException("Stub!"); } + +public boolean equals(java.lang.Object other) { throw new RuntimeException("Stub!"); } + +public int hashCode() { throw new RuntimeException("Stub!"); } + +public java.lang.String getAlias() { throw new RuntimeException("Stub!"); } + +public com.google.firebase.firestore.pipeline.Expression getExpr() { throw new RuntimeException("Stub!"); } +} + + + +// File: BooleanExpression.java +// Copyright 2025 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file 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. +// Ensure this overload exists or is correctly placed +// /** +// * Perform a full-text search on the specified field. +// * +// * Note: This Expression can only be used within a `Search` stage. +// * +// * @example +// * ```kotlin +// * db.pipeline().collection("restaurants").search( +// * SearchStage(query = matches("menu", "waffles")) +// * ) +// * ``` +// * +// * @param fieldName Perform search on this field. +// * @param rquery Define the search query using the search DSL. +// */ +// // TODO(search) this is internal until supported by the backend +// @Beta +// @JvmStatic +// internal fun matches(fieldName: String, rquery: String): BooleanExpression = +// matches(field(fieldName), rquery) +// +// /** +// * Perform a full-text search on the specified field. +// * +// * Note: This Expression can only be used within a `Search` stage. +// * +// * @example +// * ```kotlin +// * db.pipeline().collection("restaurants").search( +// * SearchStage(query = matches(field("menu"), "waffles")) +// * ) +// * ``` +// * +// * @param field Perform search on this field. +// * @param rquery Define the search query using the search DSL. +// */ +// // TODO(search) this is internal until supported by the backend +// @Beta +// @JvmStatic +// internal fun matches(field: Field, rquery: String): BooleanExpression = +// BooleanFunctionExpression("matches", notImplemented, field, constant(rquery)) +// /** +// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search +// query +// * in `bold`. +// * +// * This Expression can only be used within a `Search` stage. +// * +// * @example +// * ```kotlin +// * db.pipeline().collection("restaurants").search( +// * SearchStage(query = documentMatches("waffles"), addFields = arrayOf(snippet("menu", +// "waffles").alias("snippet"))) +// * ) +// * ``` +// * +// * @param fieldName Search the specified field for matching terms. +// * @param rquery Define the search query using the search DSL. +// */ +// @Beta +// @JvmStatic +// fun snippet(fieldName: String, rquery: String): Expression = +// FunctionExpression("snippet", notImplemented, field(fieldName), constant(rquery)) +// /** +// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search +// query +// * in `bold`. +// * +// * This Expression can only be used within a `Search` stage. +// * +// * @param fieldName Search the specified field for matching terms. +// * @param options Define how the snippet is generated. +// */ +// // TODO(search) snippet with options is internal and unimplemented until supported by the +// // backend +// @Beta +// @JvmStatic +// internal fun snippet(fieldName: String, options: SnippetOptions): Expression { +// throw NotImplementedError("Not implemented") +// } +// /** +// * Evaluates if the value in the field specified by `fieldName` is between the evaluated +// values +// * for `lowerBound` (inclusive) and `upperBound` (inclusive). +// * +// * @param fieldName Determine if this field is between two bounds. +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// */ +// // TODO(search) between is internal and unimplemented until supported by the backend +// @JvmStatic +// internal fun between( +// fieldName: String, +// lowerBound: Expression, +// upperBound: Expression +// ): BooleanExpression = +// BooleanFunctionExpression("between", notImplemented, fieldName, lowerBound, upperBound) +// /** +// * Evaluates if the value in the field specified by `fieldName` is between the values for +// * `lowerBound` (inclusive) and `upperBound` (inclusive). +// * +// * @param fieldName Determine if this field is between two bounds. +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// */ +// @JvmStatic +// internal fun between(fieldName: String, lowerBound: Any, upperBound: Any): +// BooleanExpression = +// between(fieldName, toExprOrConstant(lowerBound), toExprOrConstant(upperBound)) +// /** +// * Evaluates if the result of the specified `expression` is between the results of +// `lowerBound` +// * (inclusive) and `upperBound` (inclusive). +// * +// * @param expression Determine if the result of this expression is between two bounds. +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// */ +// @JvmStatic +// internal fun between( +// expression: Expression, +// lowerBound: Expression, +// upperBound: Expression +// ): BooleanExpression = +// BooleanFunctionExpression("between", notImplemented, expression, lowerBound, upperBound) +// /** +// * Evaluates if the result of the specified `expression` is between the `lowerBound` +// (inclusive) +// * and `upperBound` (inclusive). +// * +// * @param expression Determine if the result of this expression is between two bounds. +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// */ +// @JvmStatic +// internal fun between( +// expression: Expression, +// lowerBound: Any, +// upperBound: Any +// ): BooleanExpression = +// between(expression, toExprOrConstant(lowerBound), toExprOrConstant(upperBound)) +// // TODO(search) SnippetOptions is internal until supported by the backend +// @Beta +// internal class SnippetOptions private constructor(options: InternalOptions) : +// AbstractOptions(options) { +// /** Creates a new, empty `SnippetOptions` object. */ +// constructor(rquery: String) : this(InternalOptions.EMPTY.with("query", encodeValue(rquery))) +// +// fun withMaxSnippetWidth(max: Int): SnippetOptions { +// return with("max_snippet_width", encodeValue(max)) +// } +// +// fun withMaxSnippets(max: Int): SnippetOptions { +// return with("max_snippets", encodeValue(max)) +// } +// +// fun withSeparator(separator: String): SnippetOptions { +// return with("separator", encodeValue(separator)) +// } +// +// internal override fun self(options: InternalOptions): SnippetOptions { +// return SnippetOptions(options) +// } +// } +// /** +// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search query +// in +// * `bold`. +// * +// * Note: This Expression can only be used within a `Search` stage. +// * +// * @param rquery Define the search query using the search DTS. +// */ +// @Beta +// fun snippet(rquery: String): Expression = +// FunctionExpression( +// "snippet", +// notImplemented, +// arrayOf(this, constant(rquery)), +// SnippetOptions(rquery).options +// ) +// +// /** +// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search query +// in +// * `bold`. +// * +// * Note: This Expression can only be used within a `Search` stage. +// * +// * @param options Define how the snippet is generated. +// * +// * TODO(search) implement snippet with SnippetOptions - out of scope for first release +// */ +// @Beta +// internal fun snippet(options: SnippetOptions): Expression { +// throw NotImplementedError() +// } +// +// /** +// * Evaluates if the result of this `expression` is between the `lowerBound` (inclusive) and +// * `upperBound` (inclusive). +// * +// * @example +// * ``` +// * // Evaluate if the 'tireWidth' is between 2.2 and 2.4 +// * field('tireWidth').between(constant(2.2), constant(2.4)) +// * +// * // This is functionally equivalent to +// * and( +// * field('tireWidth').greaterThanOrEqual(constant(2.2)), +// * field('tireWidth').lessThanOrEqual(constant(2.4))) +// * ``` +// * +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// * +// * TODO(search) publish between - out of scope for first release +// */ +// internal fun between(lowerBound: Expression, upperBound: Expression): BooleanExpression = +// Companion.between(this, lowerBound, upperBound) +// +// /** +// * Evaluates if the result of this `expression` is between the `lowerBound` (inclusive) and +// * `upperBound` (inclusive). +// * +// * @example +// * ``` +// * // Evaluate if the 'tireWidth' is between 2.2 and 2.4 +// * field('tireWidth').between(2.2, 2.4) +// * +// * // This is functionally equivalent to +// * and( +// * field('tireWidth').greaterThanOrEqual(2.2), +// * field('tireWidth').lessThanOrEqual(2.4)) +// * ``` +// * +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// * +// * TODO(search) publish between - out of scope for first release +// */ +// internal fun between(lowerBound: Any, upperBound: Any): BooleanExpression = +// Companion.between(this, lowerBound, upperBound) +// +// This block runs only if fieldValue is not null. +// This value is used if getField() returns null. +// /** +// * Perform a full-text search on this field. +// * +// * Note: This Expression can only be used within a `Search` stage. +// * +// * @param rquery Define the search query using the rquery DTS. +// */ +// @Beta internal fun matches(rquery: String): BooleanExpression = matches(this, rquery) +package com.google.firebase.firestore.pipeline; + + +/** A class that represents a filter condition. */ + +@SuppressWarnings({"unchecked", "deprecation", "all"}) +public abstract class BooleanExpression extends com.google.firebase.firestore.pipeline.Expression { + +/** A class that represents a filter condition. */ + +public BooleanExpression() { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that counts the number of stage inputs where the this boolean expression + * evaluates to true. + * + * @return A new [AggregateFunction] representing the count aggregation. + */ + +public final com.google.firebase.firestore.pipeline.AggregateFunction countIf() { throw new RuntimeException("Stub!"); } + +/** + * Creates a conditional expression that evaluates to a [thenExpr] expression if this condition is + * true or an [elseExpr] expression if the condition is false. + * + * @param thenExpr The expression to evaluate if the condition is true. + * @param elseExpr The expression to evaluate if the condition is false. + * @return A new [Expression] representing the conditional operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression conditional(com.google.firebase.firestore.pipeline.Expression thenExpr, com.google.firebase.firestore.pipeline.Expression elseExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates a conditional expression that evaluates to a [thenValue] if this condition is true or + * an [elseValue] if the condition is false. + * + * @param thenValue Value if the condition is true. + * @param elseValue Value if the condition is false. + * @return A new [Expression] representing the conditional operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression conditional(java.lang.Object thenValue, java.lang.Object elseValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that negates this boolean expression. + * + * @return A new [BooleanExpression] representing the not operation. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression not() { throw new RuntimeException("Stub!"); } + +/** + * Creates a 'raw' boolean function expression. This is useful if the expression is available in + * the backend, but not yet in the current version of the SDK yet. + * + * ```kotlin + * // Create a raw boolean function call + * BooleanExpression.rawFunction("my_boolean_function", field("arg1"), constant(true)) + * ``` + * + * @param name The name of the raw function. + * @param expr The expressions to be passed as arguments to the function. + * @return A new [BooleanExpression] representing the raw function. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression rawFunction(java.lang.String name, com.google.firebase.firestore.pipeline.Expression... expr) { throw new RuntimeException("Stub!"); } + +public static final com.google.firebase.firestore.pipeline.BooleanExpression.Companion Companion; +static { Companion = null; } +@SuppressWarnings({"unchecked", "deprecation", "all"}) +public static final class Companion { + +Companion() { throw new RuntimeException("Stub!"); } + +/** + * Creates a 'raw' boolean function expression. This is useful if the expression is available in + * the backend, but not yet in the current version of the SDK yet. + * + * ```kotlin + * // Create a raw boolean function call + * BooleanExpression.rawFunction("my_boolean_function", field("arg1"), constant(true)) + * ``` + * + * @param name The name of the raw function. + * @param expr The expressions to be passed as arguments to the function. + * @return A new [BooleanExpression] representing the raw function. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression rawFunction(java.lang.String name, com.google.firebase.firestore.pipeline.Expression... expr) { throw new RuntimeException("Stub!"); } +} + +} + + + +// File: Expression.java +// Copyright 2025 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file 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. +// Ensure this overload exists or is correctly placed +// /** +// * Perform a full-text search on the specified field. +// * +// * Note: This Expression can only be used within a `Search` stage. +// * +// * @example +// * ```kotlin +// * db.pipeline().collection("restaurants").search( +// * SearchStage(query = matches("menu", "waffles")) +// * ) +// * ``` +// * +// * @param fieldName Perform search on this field. +// * @param rquery Define the search query using the search DSL. +// */ +// // TODO(search) this is internal until supported by the backend +// @Beta +// @JvmStatic +// internal fun matches(fieldName: String, rquery: String): BooleanExpression = +// matches(field(fieldName), rquery) +// +// /** +// * Perform a full-text search on the specified field. +// * +// * Note: This Expression can only be used within a `Search` stage. +// * +// * @example +// * ```kotlin +// * db.pipeline().collection("restaurants").search( +// * SearchStage(query = matches(field("menu"), "waffles")) +// * ) +// * ``` +// * +// * @param field Perform search on this field. +// * @param rquery Define the search query using the search DSL. +// */ +// // TODO(search) this is internal until supported by the backend +// @Beta +// @JvmStatic +// internal fun matches(field: Field, rquery: String): BooleanExpression = +// BooleanFunctionExpression("matches", notImplemented, field, constant(rquery)) +// /** +// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search +// query +// * in `bold`. +// * +// * This Expression can only be used within a `Search` stage. +// * +// * @example +// * ```kotlin +// * db.pipeline().collection("restaurants").search( +// * SearchStage(query = documentMatches("waffles"), addFields = arrayOf(snippet("menu", +// "waffles").alias("snippet"))) +// * ) +// * ``` +// * +// * @param fieldName Search the specified field for matching terms. +// * @param rquery Define the search query using the search DSL. +// */ +// @Beta +// @JvmStatic +// fun snippet(fieldName: String, rquery: String): Expression = +// FunctionExpression("snippet", notImplemented, field(fieldName), constant(rquery)) +// /** +// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search +// query +// * in `bold`. +// * +// * This Expression can only be used within a `Search` stage. +// * +// * @param fieldName Search the specified field for matching terms. +// * @param options Define how the snippet is generated. +// */ +// // TODO(search) snippet with options is internal and unimplemented until supported by the +// // backend +// @Beta +// @JvmStatic +// internal fun snippet(fieldName: String, options: SnippetOptions): Expression { +// throw NotImplementedError("Not implemented") +// } +// /** +// * Evaluates if the value in the field specified by `fieldName` is between the evaluated +// values +// * for `lowerBound` (inclusive) and `upperBound` (inclusive). +// * +// * @param fieldName Determine if this field is between two bounds. +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// */ +// // TODO(search) between is internal and unimplemented until supported by the backend +// @JvmStatic +// internal fun between( +// fieldName: String, +// lowerBound: Expression, +// upperBound: Expression +// ): BooleanExpression = +// BooleanFunctionExpression("between", notImplemented, fieldName, lowerBound, upperBound) +// /** +// * Evaluates if the value in the field specified by `fieldName` is between the values for +// * `lowerBound` (inclusive) and `upperBound` (inclusive). +// * +// * @param fieldName Determine if this field is between two bounds. +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// */ +// @JvmStatic +// internal fun between(fieldName: String, lowerBound: Any, upperBound: Any): +// BooleanExpression = +// between(fieldName, toExprOrConstant(lowerBound), toExprOrConstant(upperBound)) +// /** +// * Evaluates if the result of the specified `expression` is between the results of +// `lowerBound` +// * (inclusive) and `upperBound` (inclusive). +// * +// * @param expression Determine if the result of this expression is between two bounds. +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// */ +// @JvmStatic +// internal fun between( +// expression: Expression, +// lowerBound: Expression, +// upperBound: Expression +// ): BooleanExpression = +// BooleanFunctionExpression("between", notImplemented, expression, lowerBound, upperBound) +// /** +// * Evaluates if the result of the specified `expression` is between the `lowerBound` +// (inclusive) +// * and `upperBound` (inclusive). +// * +// * @param expression Determine if the result of this expression is between two bounds. +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// */ +// @JvmStatic +// internal fun between( +// expression: Expression, +// lowerBound: Any, +// upperBound: Any +// ): BooleanExpression = +// between(expression, toExprOrConstant(lowerBound), toExprOrConstant(upperBound)) +// // TODO(search) SnippetOptions is internal until supported by the backend +// @Beta +// internal class SnippetOptions private constructor(options: InternalOptions) : +// AbstractOptions(options) { +// /** Creates a new, empty `SnippetOptions` object. */ +// constructor(rquery: String) : this(InternalOptions.EMPTY.with("query", encodeValue(rquery))) +// +// fun withMaxSnippetWidth(max: Int): SnippetOptions { +// return with("max_snippet_width", encodeValue(max)) +// } +// +// fun withMaxSnippets(max: Int): SnippetOptions { +// return with("max_snippets", encodeValue(max)) +// } +// +// fun withSeparator(separator: String): SnippetOptions { +// return with("separator", encodeValue(separator)) +// } +// +// internal override fun self(options: InternalOptions): SnippetOptions { +// return SnippetOptions(options) +// } +// } +// /** +// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search query +// in +// * `bold`. +// * +// * Note: This Expression can only be used within a `Search` stage. +// * +// * @param rquery Define the search query using the search DTS. +// */ +// @Beta +// fun snippet(rquery: String): Expression = +// FunctionExpression( +// "snippet", +// notImplemented, +// arrayOf(this, constant(rquery)), +// SnippetOptions(rquery).options +// ) +// +// /** +// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search query +// in +// * `bold`. +// * +// * Note: This Expression can only be used within a `Search` stage. +// * +// * @param options Define how the snippet is generated. +// * +// * TODO(search) implement snippet with SnippetOptions - out of scope for first release +// */ +// @Beta +// internal fun snippet(options: SnippetOptions): Expression { +// throw NotImplementedError() +// } +// +// /** +// * Evaluates if the result of this `expression` is between the `lowerBound` (inclusive) and +// * `upperBound` (inclusive). +// * +// * @example +// * ``` +// * // Evaluate if the 'tireWidth' is between 2.2 and 2.4 +// * field('tireWidth').between(constant(2.2), constant(2.4)) +// * +// * // This is functionally equivalent to +// * and( +// * field('tireWidth').greaterThanOrEqual(constant(2.2)), +// * field('tireWidth').lessThanOrEqual(constant(2.4))) +// * ``` +// * +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// * +// * TODO(search) publish between - out of scope for first release +// */ +// internal fun between(lowerBound: Expression, upperBound: Expression): BooleanExpression = +// Companion.between(this, lowerBound, upperBound) +// +// /** +// * Evaluates if the result of this `expression` is between the `lowerBound` (inclusive) and +// * `upperBound` (inclusive). +// * +// * @example +// * ``` +// * // Evaluate if the 'tireWidth' is between 2.2 and 2.4 +// * field('tireWidth').between(2.2, 2.4) +// * +// * // This is functionally equivalent to +// * and( +// * field('tireWidth').greaterThanOrEqual(2.2), +// * field('tireWidth').lessThanOrEqual(2.4)) +// * ``` +// * +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// * +// * TODO(search) publish between - out of scope for first release +// */ +// internal fun between(lowerBound: Any, upperBound: Any): BooleanExpression = +// Companion.between(this, lowerBound, upperBound) +// +// This block runs only if fieldValue is not null. +// This value is used if getField() returns null. +// /** +// * Perform a full-text search on this field. +// * +// * Note: This Expression can only be used within a `Search` stage. +// * +// * @param rquery Define the search query using the rquery DTS. +// */ +// @Beta internal fun matches(rquery: String): BooleanExpression = matches(this, rquery) +package com.google.firebase.firestore.pipeline; + + +/** + * Represents an expression that can be evaluated to a value within the execution of a [Pipeline]. + * + * Expressions are the building blocks for creating complex queries and transformations in Firestore + * pipelines. They can represent: + * + * - **Field references:** Access values from document fields. + * - **Literals:** Represent constant values (strings, numbers, booleans). + * - **Function calls:** Apply functions to one or more expressions. + * + * The [Expression] class provides a fluent API for building expressions. You can chain together + * method calls to create complex expressions. + */ + +@SuppressWarnings({"unchecked", "deprecation", "all"}) +public abstract class Expression { + +Expression() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise AND operation with other expression. + * + * ```kotlin + * // Bitwise AND the value of the 'flags' field with the value of the 'mask' field. + * field("flags").bitAnd(field("mask")) + * ``` + * + * @param bitsOther An expression that returns bits when evaluated. + * @return A new [Expression] representing the bitwise AND operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression bitAnd(com.google.firebase.firestore.pipeline.Expression bitsOther) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise AND operation with a constant. + * + * ```kotlin + * // Bitwise AND the value of the 'flags' field with a constant mask. + * field("flags").bitAnd(byteArrayOf(0b00001111)) + * ``` + * + * @param bitsOther A constant byte array. + * @return A new [Expression] representing the bitwise AND operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression bitAnd(byte[] bitsOther) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise OR operation with other expression. + * + * ```kotlin + * // Bitwise OR the value of the 'flags' field with the value of the 'mask' field. + * field("flags").bitOr(field("mask")) + * ``` + * + * @param bitsOther An expression that returns bits when evaluated. + * @return A new [Expression] representing the bitwise OR operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression bitOr(com.google.firebase.firestore.pipeline.Expression bitsOther) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise OR operation with a constant. + * + * ```kotlin + * // Bitwise OR the value of the 'flags' field with a constant mask. + * field("flags").bitOr(byteArrayOf(0b00001111)) + * ``` + * + * @param bitsOther A constant byte array. + * @return A new [Expression] representing the bitwise OR operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression bitOr(byte[] bitsOther) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise XOR operation with an expression. + * + * ```kotlin + * // Bitwise XOR the value of the 'flags' field with the value of the 'mask' field. + * field("flags").bitXor(field("mask")) + * ``` + * + * @param bitsOther An expression that returns bits when evaluated. + * @return A new [Expression] representing the bitwise XOR operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression bitXor(com.google.firebase.firestore.pipeline.Expression bitsOther) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise XOR operation with a constant. + * + * ```kotlin + * // Bitwise XOR the value of the 'flags' field with a constant mask. + * field("flags").bitXor(byteArrayOf(0b00001111)) + * ``` + * + * @param bitsOther A constant byte array. + * @return A new [Expression] representing the bitwise XOR operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression bitXor(byte[] bitsOther) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise NOT operation to this expression. + * + * ```kotlin + * // Bitwise NOT the value of the 'flags' field. + * field("flags").bitNot() + * ``` + * + * @return A new [Expression] representing the bitwise NOT operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression bitNot() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise left shift operation with an expression. + * + * ```kotlin + * // Left shift the value of the 'bits' field by the value of the 'shift' field. + * field("bits").bitLeftShift(field("shift")) + * ``` + * + * @param numberExpr The number of bits to shift. + * @return A new [Expression] representing the bitwise left shift operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression bitLeftShift(com.google.firebase.firestore.pipeline.Expression numberExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise left shift operation with a constant. + * + * ```kotlin + * // Left shift the value of the 'bits' field by 2. + * field("bits").bitLeftShift(2) + * ``` + * + * @param number The number of bits to shift. + * @return A new [Expression] representing the bitwise left shift operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression bitLeftShift(int number) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise right shift operation with an expression. + * + * ```kotlin + * // Right shift the value of the 'bits' field by the value of the 'shift' field. + * field("bits").bitRightShift(field("shift")) + * ``` + * + * @param numberExpr The number of bits to shift. + * @return A new [Expression] representing the bitwise right shift operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression bitRightShift(com.google.firebase.firestore.pipeline.Expression numberExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise right shift operation with a constant. + * + * ```kotlin + * // Right shift the value of the 'bits' field by 2. + * field("bits").bitRightShift(2) + * ``` + * + * @param number The number of bits to shift. + * @return A new [Expression] representing the bitwise right shift operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression bitRightShift(int number) { throw new RuntimeException("Stub!"); } + +/** + * Assigns an alias to this expression. + * + * Aliases are useful for renaming fields in the output of a stage or for giving meaningful names + * to calculated values. + * + * @param alias The alias to assign to this expression. + * @return A [AliasedExpression] that wraps this expression and associates it with the provided + * alias. + */ + +public com.google.firebase.firestore.pipeline.AliasedExpression alias(java.lang.String alias) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the document ID from this path expression. + * + * ```kotlin + * // Get the document ID from the 'path' field + * field("path").documentId() + * ``` + * + * @return A new [Expression] representing the documentId operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression documentId() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the parent document reference of this document reference + * expression. + * + * ```kotlin + * // Get the parent document reference of the 'path' field. + * field("path").parent() + * ``` + * + * @return A new [Expression] representing the parent operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression parent() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the collection ID from this path expression. + * + * ```kotlin + * // Get the collection ID from the 'path' field + * field("path").collectionId() + * ``` + * + * @return A new [Expression] representing the collectionId operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression collectionId() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the absolute value of this expression. + * + * ```kotlin + * // Get the absolute value of the 'change' field. + * field("change").abs() + * ``` + * + * @return A new [Expression] representing the numeric result of the absolute value operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression abs() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns Euler's number e raised to the power of this expression. + * + * ```kotlin + * // Compute e to the power of the 'value' field. + * field("value").exp() + * ``` + * + * @return A new [Expression] representing the numeric result of the exponentiation. + */ + +public final com.google.firebase.firestore.pipeline.Expression exp() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that adds this numeric expression to another numeric expression. + * + * ```kotlin + * // Add the value of the 'quantity' field and the 'reserve' field. + * field("quantity").add(field("reserve")) + * ``` + * + * @param second Numeric expression to add. + * @return A new [Expression] representing the addition operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression add(com.google.firebase.firestore.pipeline.Expression second) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that adds this numeric expression to a constants. + * + * ```kotlin + * // Add 5 to the value of the 'quantity' field. + * field("quantity").add(5) + * ``` + * + * @param second Constant to add. + * @return A new [Expression] representing the addition operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression add(java.lang.Number second) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that subtracts a constant from this numeric expression. + * + * ```kotlin + * // Subtract the 'discount' field from the 'price' field + * field("price").subtract(field("discount")) + * ``` + * + * @param subtrahend Numeric expression to subtract. + * @return A new [Expression] representing the subtract operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression subtract(com.google.firebase.firestore.pipeline.Expression subtrahend) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that subtracts a numeric expressions from this numeric expression. + * + * ```kotlin + * // Subtract 10 from the 'price' field. + * field("price").subtract(10) + * ``` + * + * @param subtrahend Constant to subtract. + * @return A new [Expression] representing the subtract operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression subtract(java.lang.Number subtrahend) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that multiplies this numeric expression with another numeric expression. + * + * ```kotlin + * // Multiply the 'quantity' field by the 'price' field + * field("quantity").multiply(field("price")) + * ``` + * + * @param second Numeric expression to multiply. + * @return A new [Expression] representing the multiplication operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression multiply(com.google.firebase.firestore.pipeline.Expression second) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that multiplies this numeric expression with a constant. + * + * ```kotlin + * // Multiply the 'quantity' field by 1.1. + * field("quantity").multiply(1.1) + * ``` + * + * @param second Constant to multiply. + * @return A new [Expression] representing the multiplication operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression multiply(java.lang.Number second) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that divides this numeric expression by another numeric expression. + * + * ```kotlin + * // Divide the 'total' field by the 'count' field + * field("total").divide(field("count")) + * ``` + * + * @param divisor Numeric expression to divide this numeric expression by. + * @return A new [Expression] representing the division operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression divide(com.google.firebase.firestore.pipeline.Expression divisor) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that divides this numeric expression by a constant. + * + * ```kotlin + * // Divide the 'value' field by 10 + * field("value").divide(10) + * ``` + * + * @param divisor Constant to divide this expression by. + * @return A new [Expression] representing the division operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression divide(java.lang.Number divisor) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the modulo (remainder) of dividing this numeric + * expressions by another numeric expression. + * + * ```kotlin + * // Calculate the remainder of dividing the 'value' field by the 'divisor' field + * field("value").mod(field("divisor")) + * ``` + * + * @param divisor The numeric expression to divide this expression by. + * @return A new [Expression] representing the modulo operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression mod(com.google.firebase.firestore.pipeline.Expression divisor) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the modulo (remainder) of dividing this numeric + * expressions by a constant. + * + * ```kotlin + * // Calculate the remainder of dividing the 'value' field by 3. + * field("value").mod(3) + * ``` + * + * @param divisor The constant to divide this expression by. + * @return A new [Expression] representing the modulo operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression mod(java.lang.Number divisor) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that rounds this numeric expression to nearest integer. + * + * ```kotlin + * // Round the value of the 'price' field. + * field("price").round() + * ``` + * + * Rounds away from zero in halfway cases. + * + * @return A new [Expression] representing an integer result from the round operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression round() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that rounds off this numeric expression to [decimalPlace] decimal places + * if [decimalPlace] is positive, rounds off digits to the left of the decimal point if + * [decimalPlace] is negative. Rounds away from zero in halfway cases. + * + * ```kotlin + * // Round the value of the 'price' field to 2 decimal places. + * field("price").roundToPrecision(2) + * ``` + * + * @param decimalPlace The number of decimal places to round. + * @return A new [Expression] representing the round operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression roundToPrecision(int decimalPlace) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that rounds off this numeric expression to [decimalPlace] decimal places + * if [decimalPlace] is positive, rounds off digits to the left of the decimal point if + * [decimalPlace] is negative. Rounds away from zero in halfway cases. + * + * ```kotlin + * // Round the value of the 'price' field to the number of decimal places specified in the + * // 'precision' field. + * field("price").roundToPrecision(field("precision")) + * ``` + * + * @param decimalPlace The number of decimal places to round. + * @return A new [Expression] representing the round operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression roundToPrecision(com.google.firebase.firestore.pipeline.Expression decimalPlace) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates this numeric expression to an integer. + * + * ```kotlin + * // Truncate the value of the 'rating' field. + * field("rating").trunc() + * ``` + * + * @return A new [Expression] representing the truncate operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression trunc() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates this numeric expression to [decimalPlace] decimal places + * if [decimalPlace] is positive, truncates digits to the left of the decimal point if + * [decimalPlace] is negative. + * + * ```kotlin + * // Truncate the value of the 'rating' field to 2 decimal places. + * field("rating").truncToPrecision(2) + * ``` + * + * @param decimalPlace The number of decimal places to truncate. + * @return A new [Expression] representing the truncate operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression truncToPrecision(int decimalPlace) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates this numeric expression to [decimalPlace] decimal places + * if [decimalPlace] is positive, truncates digits to the left of the decimal point if + * [decimalPlace] is negative. + * + * ```kotlin + * // Truncate the value of the 'rating' field to the number of decimal places specified in the + * // 'precision' field. + * field("rating").truncToPrecision(field("precision")) + * ``` + * + * @param decimalPlace The number of decimal places to truncate. + * @return A new [Expression] representing the truncate operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression truncToPrecision(com.google.firebase.firestore.pipeline.Expression decimalPlace) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the smallest integer that isn't less than this numeric + * expression. + * + * ```kotlin + * // Compute the ceiling of the 'price' field. + * field("price").ceil() + * ``` + * + * @return A new [Expression] representing an integer result from the ceil operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression ceil() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the largest integer that is not greater than this numeric + * expression. + * + * ```kotlin + * // Compute the floor of the 'price' field. + * field("price").floor() + * ``` + * + * @return A new [Expression] representing an integer result from the floor operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression floor() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns this numeric expression raised to the power of the + * [exponent]. Returns infinity on overflow and zero on underflow. + * + * ```kotlin + * // Raise the value of the 'base' field to the power of 2. + * field("base").pow(2) + * ``` + * + * @param exponent The numeric power to raise this numeric expression. + * @return A new [Expression] representing a numeric result from raising this numeric expression + * to the power of [exponent]. + */ + +public final com.google.firebase.firestore.pipeline.Expression pow(java.lang.Number exponent) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns this numeric expression raised to the power of the + * [exponent]. Returns infinity on overflow and zero on underflow. + * + * ```kotlin + * // Raise the value of the 'base' field to the power of the 'exponent' field. + * field("base").pow(field("exponent")) + * ``` + * + * @param exponent The numeric power to raise this numeric expression. + * @return A new [Expression] representing a numeric result from raising this numeric expression + * to the power of [exponent]. + */ + +public final com.google.firebase.firestore.pipeline.Expression pow(com.google.firebase.firestore.pipeline.Expression exponent) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the square root of this numeric expression. + * + * ```kotlin + * // Compute the square root of the 'value' field. + * field("value").sqrt() + * ``` + * + * @return A new [Expression] representing the numeric result of the square root operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression sqrt() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the natural logarithm of this numeric expression. + * + * ```kotlin + * // compute the natural logarithm of the 'value' field. + * field("value").ln() + * ``` + * + * @return A new [Expression] representing the numeric result of the natural logarithm operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression ln() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the base-10 logarithm of this numeric expression. + * + * ```kotlin + * // compute the base-10 logarithm of the 'value' field. + * field("value").log10() + * ``` + * + * @return A new [Expression] representing the numeric result of the base-10 logarithm operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression log10() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if this expression, when evaluated, is equal to any of the + * provided [values]. + * + * ```kotlin + * // Check if the 'category' field is either "Electronics" or the value of the 'primaryType' field. + * field("category").equalAny(listOf("Electronics", field("primaryType"))) + * ``` + * + * @param values The values to check against. + * @return A new [BooleanExpression] representing the 'IN' comparison. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression equalAny(java.util.List values) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if this expression, when evaluated, is equal to any of the + * elements of [arrayExpression]. + * + * ```kotlin + * // Check if the 'category' field is in the 'availableCategories' array field. + * field("category").equalAny(field("availableCategories")) + * ``` + * + * @param arrayExpression An expression that evaluates to an array, whose elements to check for + * equality to the input. + * @return A new [BooleanExpression] representing the 'IN' comparison. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression equalAny(com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if this expression, when evaluated, is not equal to all the + * provided [values]. + * + * ```kotlin + * // Check if the 'status' field is neither "pending" nor the value of the 'rejectedStatus' field. + * field("status").notEqualAny(listOf("pending", field("rejectedStatus"))) + * ``` + * + * @param values The values to check against. + * @return A new [BooleanExpression] representing the 'NOT IN' comparison. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression notEqualAny(java.util.List values) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if this expression, when evaluated, is not equal to all the + * elements of [arrayExpression]. + * + * ```kotlin + * // Check if the 'status' field is not in the 'inactiveStatuses' array field. + * field("status").notEqualAny(field("inactiveStatuses")) + * ``` + * + * @param arrayExpression An expression that evaluates to an array, whose elements to check for + * equality to the input. + * @return A new [BooleanExpression] representing the 'NOT IN' comparison. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression notEqualAny(com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns true if the result of this expression is absent. Otherwise, + * returns false even if the value is null. + * + * ```kotlin + * // Check if the field `value` is absent. + * field("value").isAbsent() + * ``` + * + * @return A new [BooleanExpression] representing the isAbsent operation. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression isAbsent() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the length of a string, array, map, vector, or blob + * expression. + * + * ```kotlin + * // Get the length of the 'value' field where the value type can be any of a string, array, map, vector or blob. + * field("value").length() + * ``` + * + * @return A new [Expression] representing the length operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression length() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the character length of this string expression in UTF8. + * + * ```kotlin + * // Get the character length of the 'name' field in UTF-8. + * field("name").charLength() + * ``` + * + * @return A new [Expression] representing the charLength operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression charLength() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the length of a string in UTF-8 bytes, or just the length + * of a Blob. + * + * ```kotlin + * // Calculate the length of the 'myString' field in bytes. + * field("myString").byteLength() + * ``` + * + * @return A new [Expression] representing the length of the string in bytes. + */ + +public final com.google.firebase.firestore.pipeline.Expression byteLength() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that performs a case-sensitive wildcard string comparison. + * + * ```kotlin + * // Check if the 'title' field contains the string "guide" + * field("title").like("%guide%") + * ``` + * + * @param pattern The pattern to search for. You can use "%" as a wildcard character. + * @return A new [BooleanExpression] representing the like operation. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression like(com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a string indicating the type of the value this expression + * evaluates to. + * + * ```kotlin + * // Get the type of the 'value' field. + * field("value").type() + * ``` + * + * @return A new [Expression] representing the type operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression type() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if the result of this expression is of the given type. + * + * Supported values for `type` are: "null", "array", "boolean", "bytes", "timestamp", "geo_point", + * "number", "int32", "int64", "float64", "decimal128", "map", "reference", "string", "vector", + * "max_key", "min_key", "object_id", "regex", and "request_timestamp". + * + * ```kotlin + * // Check if the 'age' field is an integer + * field("age").isType("int64") + * ``` + * + * @param type The type to check for. + * @return A new [BooleanExpression] that evaluates to true if the expression's result is of the + * given type, false otherwise. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression isType(java.lang.String type) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that splits this string or blob expression by a delimiter. + * + * ```kotlin + * // Split the 'tags' field by a comma + * field("tags").split(field("delimiter")) + * ``` + * + * @param delimiter The delimiter to split by. + * @return A new [Expression] that evaluates to an array of segments. + */ + +public final com.google.firebase.firestore.pipeline.Expression split(com.google.firebase.firestore.pipeline.Expression delimiter) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that splits this string or blob expression by a string delimiter. + * + * ```kotlin + * // Split the 'tags' field by a comma + * field("tags").split(",") + * ``` + * + * @param delimiter The string delimiter to split by. + * @return A new [Expression] that evaluates to an array of segments. + */ + +public final com.google.firebase.firestore.pipeline.Expression split(java.lang.String delimiter) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that splits this blob expression by a blob delimiter. + * + * ```kotlin + * // Split the 'data' field by a delimiter + * field("data").split(Blob.fromBytes(byteArrayOf(0x0a))) + * ``` + * + * @param delimiter The blob delimiter to split by. + * @return A new [Expression] that evaluates to an array of segments. + */ + +public final com.google.firebase.firestore.pipeline.Expression split(com.google.firebase.firestore.Blob delimiter) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that joins the elements of an array into a string. + * + * ```kotlin + * // Join the elements of the 'tags' field with a comma and space. + * field("tags").join(", ") + * ``` + * + * @param delimiter The string to use as a delimiter. + * @return A new [Expression] representing the join operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression join(java.lang.String delimiter) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that joins the elements of an array into a string. + * + * ```kotlin + * // Join the elements of the 'tags' field with the delimiter from the 'separator' field. + * field("tags").join(field("separator")) + * ``` + * + * @param delimiterExpression The expression that evaluates to the delimiter string. + * @return A new [Expression] representing the join operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression join(com.google.firebase.firestore.pipeline.Expression delimiterExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that performs a case-sensitive wildcard string comparison. + * + * ```kotlin + * // Check if the 'title' field contains the string "guide" + * field("title").like("%guide%") + * ``` + * + * @param pattern The pattern to search for. You can use "%" as a wildcard character. + * @return A new [BooleanExpression] representing the like operation. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression like(java.lang.String pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if this string expression contains a specified regular + * expression as a substring. + * + * ```kotlin + * // Check if the 'description' field contains "example" (case-insensitive) + * field("description").regexContains("(?i)example") + * ``` + * + * @param pattern The regular expression to use for the search. + * @return A new [BooleanExpression] representing the contains regular expression comparison. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression regexContains(com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if this string expression contains a specified regular + * expression as a substring. + * + * ```kotlin + * // Check if the 'description' field contains "example" (case-insensitive) + * field("description").regexContains("(?i)example") + * ``` + * + * @param pattern The regular expression to use for the search. + * @return A new [BooleanExpression] representing the contains regular expression comparison. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression regexContains(java.lang.String pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if this string expression matches a specified regular + * expression. + * + * ```kotlin + * // Check if the 'email' field matches a valid email pattern + * field("email").regexMatch("[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}") + * ``` + * + * @param pattern The regular expression to use for the match. + * @return A new [BooleanExpression] representing the regular expression match comparison. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression regexMatch(com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if this string expression matches a specified regular + * expression. + * + * ```kotlin + * // Check if the 'email' field matches a valid email pattern + * field("email").regexMatch("[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}") + * ``` + * + * @param pattern The regular expression to use for the match. + * @return A new [BooleanExpression] representing the regular expression match comparison. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression regexMatch(java.lang.String pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the largest value between multiple input expressions or + * literal values. Based on Firestore's value type ordering. + * + * ```kotlin + * // Returns the larger value between the 'timestamp' field and the current timestamp. + * field("timestamp").logicalMaximum(currentTimestamp()) + * ``` + * + * @param others Expressions or literals. + * @return A new [Expression] representing the logical maximum operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression logicalMaximum(com.google.firebase.firestore.pipeline.Expression... others) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the largest value between multiple input expressions or + * literal values. Based on Firestore's value type ordering. + * + * ```kotlin + * // Returns the larger value between the 'timestamp' field and the current timestamp. + * field("timestamp").logicalMaximum(currentTimestamp()) + * ``` + * + * @param others Expressions or literals. + * @return A new [Expression] representing the logical maximum operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression logicalMaximum(java.lang.Object... others) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the smallest value between multiple input expressions or + * literal values. Based on Firestore's value type ordering. + * + * ```kotlin + * // Returns the smaller value between the 'timestamp' field and the current timestamp. + * field("timestamp").logicalMinimum(currentTimestamp()) + * ``` + * + * @param others Expressions or literals. + * @return A new [Expression] representing the logical minimum operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression logicalMinimum(com.google.firebase.firestore.pipeline.Expression... others) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the smallest value between multiple input expressions or + * literal values. Based on Firestore's value type ordering. + * + * ```kotlin + * // Returns the smaller value between the 'timestamp' field and the current timestamp. + * field("timestamp").logicalMinimum(currentTimestamp()) + * ``` + * + * @param others Expressions or literals. + * @return A new [Expression] representing the logical minimum operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression logicalMinimum(java.lang.Object... others) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that reverses this string expression. + * + * ```kotlin + * // Reverse the value of the 'myString' field. + * field("myString").reverse() + * ``` + * + * @return A new [Expression] representing the reversed string. + */ + +public final com.google.firebase.firestore.pipeline.Expression reverse() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if this string expression contains a specified substring. + * + * ```kotlin + * // Check if the 'description' field contains the value of the 'keyword' field. + * field("description").stringContains(field("keyword")) + * ``` + * + * @param substring The expression representing the substring to search for. + * @return A new [BooleanExpression] representing the contains comparison. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression stringContains(com.google.firebase.firestore.pipeline.Expression substring) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if this string expression contains a specified substring. + * + * ```kotlin + * // Check if the 'description' field contains "example". + * field("description").stringContains("example") + * ``` + * + * @param substring The substring to search for. + * @return A new [BooleanExpression] representing the contains comparison. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression stringContains(java.lang.String substring) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if this string expression starts with a given [prefix]. + * + * ```kotlin + * // Check if the 'fullName' field starts with the value of the 'firstName' field + * field("fullName").startsWith(field("firstName")) + * ``` + * + * @param prefix The prefix string expression to check for. + * @return A new [BooleanExpression] representing the 'starts with' comparison. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression startsWith(com.google.firebase.firestore.pipeline.Expression prefix) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if this string expression starts with a given [prefix]. + * + * ```kotlin + * // Check if the 'name' field starts with "Mr." + * field("name").startsWith("Mr.") + * ``` + * + * @param prefix The prefix string to check for. + * @return A new [BooleanExpression] representing the 'starts with' comparison. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression startsWith(java.lang.String prefix) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if this string expression ends with a given [suffix]. + * + * ```kotlin + * // Check if the 'url' field ends with the value of the 'extension' field + * field("url").endsWith(field("extension")) + * ``` + * + * @param suffix The suffix string expression to check for. + * @return A new [BooleanExpression] representing the 'ends with' comparison. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression endsWith(com.google.firebase.firestore.pipeline.Expression suffix) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if this string expression ends with a given [suffix]. + * + * ```kotlin + * // Check if the 'filename' field ends with ".txt" + * field("filename").endsWith(".txt") + * ``` + * + * @param suffix The suffix string to check for. + * @return A new [BooleanExpression] representing the 'ends with' comparison. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression endsWith(java.lang.String suffix) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that performs a reverse operation on this string expression. + * + * ```kotlin + * // reverse the field "filename": "abc.txt" => "txt.cba" + * field("filename").stringReverse() + * ``` + * @return A new [Expression] representing the 'stringReverse' operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression stringReverse() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a substring of the given string. + * + * ```kotlin + * // Get a substring of the 'message' field starting at index 5 with length 10. + * field("message").substring(constant(5), constant(10)) + * ``` + * + * @param start The starting index of the substring. + * @param length The length of the substring. + * @return A new [Expression] representing the substring. + */ + +public final com.google.firebase.firestore.pipeline.Expression substring(com.google.firebase.firestore.pipeline.Expression start, com.google.firebase.firestore.pipeline.Expression length) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a substring of the given string. + * + * ```kotlin + * // Get a substring of the 'message' field starting at index 5 with length 10. + * field("message").substring(5, 10) + * ``` + * + * @param start The starting index of the substring. + * @param length The length of the substring. + * @return A new [Expression] representing the substring. + */ + +public final com.google.firebase.firestore.pipeline.Expression substring(int start, int length) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that converts this string expression to lowercase. + * + * ```kotlin + * // Convert the 'name' field to lowercase + * field("name").toLower() + * ``` + * + * @return A new [Expression] representing the lowercase string. + */ + +public final com.google.firebase.firestore.pipeline.Expression toLower() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that converts this string expression to uppercase. + * + * ```kotlin + * // Convert the 'title' field to uppercase + * field("title").toUpper() + * ``` + * + * @return A new [Expression] representing the uppercase string. + */ + +public final com.google.firebase.firestore.pipeline.Expression toUpper() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes leading and trailing whitespace from this string expression. + * + * ```kotlin + * // Trim whitespace from the 'userInput' field + * field("userInput").trim() + * ``` + * + * @return A new [Expression] representing the trimmed string. + */ + +public final com.google.firebase.firestore.pipeline.Expression trim() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes a set of leading and trailing values from this string + * expression. + * + * Note: The values to trim are treated as a **set**, not a substring. + * + * ```kotlin + * // Trim all '_' and '-' characters from the 'userInput' field + * field("userInput").trimValue("-_") + * ``` + * + * @param valueToTrim The set of values to trim from the string. + * @return A new [Expression] representing the trimmed string. + */ + +public final com.google.firebase.firestore.pipeline.Expression trimValue(java.lang.String valueToTrim) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes a set of leading and trailing values from this expression. + * The accepted types are string and blob. + * + * Note: The values to trim are treated as a **set**, not a substring. + * + * ```kotlin + * // Trim specified characters from the 'userInput' field + * field("userInput").trimValue(field("trimChars")) + * ``` + * + * @param valueToTrim The expression representing the set of values to trim from the string. + * @return A new [Expression] representing the trimmed string. + */ + +public final com.google.firebase.firestore.pipeline.Expression trimValue(com.google.firebase.firestore.pipeline.Expression valueToTrim) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes leading whitespace from this string expression. + * + * ```kotlin + * // Trim leading whitespace from the 'text' field. + * field("text").ltrim() + * ``` + * + * @return A new [Expression] representing the ltrim operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression ltrim() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes a set of leading values from this string expression. + * + * Note: The values to trim are treated as a **set**, not a substring. + * + * ```kotlin + * // Trim all leading '-' and '_' characters from the 'text' field. + * field("text").ltrimValue("-_") + * ``` + * + * @param valuesToTrim The string of characters to remove. + * @return A new [Expression] representing the ltrim operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression ltrimValue(java.lang.String valuesToTrim) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes a set of leading values from this string expression. + * + * Note: The values to trim are treated as a **set**, not a substring. + * + * ```kotlin + * // Trim leading characters defined by the 'chars' field from the 'text' field. + * field("text").ltrimValue(field("chars")) + * ``` + * + * @param valuesToTrim The expression representing the set of values to remove. + * @return A new [Expression] representing the ltrim operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression ltrimValue(com.google.firebase.firestore.pipeline.Expression valuesToTrim) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes trailing whitespace from this string expression. + * + * ```kotlin + * // Trim trailing whitespace from the 'text' field. + * field("text").rtrim() + * ``` + * + * @return A new [Expression] representing the rtrim operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression rtrim() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes a set of trailing characters from this string expression. + * + * Note: The values to trim are treated as a **set**, not a substring. + * + * ```kotlin + * // Trim all trailing '-' and '_' characters from the 'text' field. + * field("text").rtrimValue("-_") + * ``` + * + * @param valuesToTrim The set of values to remove. + * @return A new [Expression] representing the rtrim operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression rtrimValue(java.lang.String valuesToTrim) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes a set of trailing values from this string expression. + * + * Note: The values to trim are treated as a **set**, not a substring. + * + * ```kotlin + * // Trim trailing characters defined by the 'chars' field from the 'text' field. + * field("text").rtrimValue(field("chars")) + * ``` + * + * @param valuesToTrim The expression representing the set of values to remove. + * @return A new [Expression] representing the rtrim operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression rtrimValue(com.google.firebase.firestore.pipeline.Expression valuesToTrim) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that repeats this string expression a given number of times. + * + * ```kotlin + * // Repeat the 'name' field 3 times. + * field("name").stringRepeat(3) + * ``` + * + * @param count The number of times to repeat the string. + * @return A new [Expression] representing the stringRepeat operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression stringRepeat(int count) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that repeats this string expression a given number of times. + * + * ```kotlin + * // Repeat the 'name' field the number of times specified in the 'count' field. + * field("name").stringRepeat(field("count")) + * ``` + * + * @param count The expression representing the number of times to repeat the string. + * @return A new [Expression] representing the stringRepeat operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression stringRepeat(com.google.firebase.firestore.pipeline.Expression count) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that replaces all occurrences of a substring with another string. + * + * ```kotlin + * // Replace all occurrences of "cat" with "dog" in the 'text' field. + * field("text").stringReplaceAll("cat", "dog") + * ``` + * + * @param oldValue The substring to replace. + * @param newValue The replacement string. + * @return A new [Expression] representing the stringReplaceAll operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression stringReplaceAll(java.lang.String oldValue, java.lang.String newValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that replaces all occurrences of a substring with another string. + * + * ```kotlin + * // Replace all occurrences of the 'old' field with the 'new' field in 'text'. + * field("text").stringReplaceAll(field("old"), field("new")) + * ``` + * + * @param oldValue The expression representing the substring to replace. + * @param newValue The expression representing the replacement string. + * @return A new [Expression] representing the stringReplaceAll operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression stringReplaceAll(com.google.firebase.firestore.pipeline.Expression oldValue, com.google.firebase.firestore.pipeline.Expression newValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that replaces the first occurrence of a substring with another string. + * + * ```kotlin + * // Replace the first occurrence of "cat" with "dog" in the 'text' field. + * field("text").stringReplaceOne("cat", "dog") + * ``` + * + * @param oldValue The substring to replace. + * @param newValue The replacement string. + * @return A new [Expression] representing the stringReplaceOne operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression stringReplaceOne(java.lang.String oldValue, java.lang.String newValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that replaces the first occurrence of a substring with another string. + * + * ```kotlin + * // Replace the first occurrence of the 'old' field with the 'new' field in 'text'. + * field("text").stringReplaceOne(field("old"), field("new")) + * ``` + * + * @param oldValue The expression representing the substring to replace. + * @param newValue The expression representing the replacement string. + * @return A new [Expression] representing the stringReplaceOne operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression stringReplaceOne(com.google.firebase.firestore.pipeline.Expression oldValue, com.google.firebase.firestore.pipeline.Expression newValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the 0-based index of the first occurrence of the specified + * substring. + * + * ```kotlin + * // Get the index of "world" within the 'text' field. + * field("text").stringIndexOf("world") + * ``` + * + * @param substring The substring to search for. + * @return A new [Expression] representing the stringIndexOf operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression stringIndexOf(java.lang.String substring) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the 0-based index of the first occurrence of the specified + * substring. + * + * ```kotlin + * // Get the index of the 'search' field within the 'text' field. + * field("text").stringIndexOf(field("search")) + * ``` + * + * @param substring The expression representing the substring to search for. + * @return A new [Expression] representing the stringIndexOf operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression stringIndexOf(com.google.firebase.firestore.pipeline.Expression substring) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that concatenates string expressions together. + * + * ```kotlin + * // Combine the 'firstName', " ", and 'lastName' fields into a single string + * field("firstName").stringConcat(constant(" "), field("lastName")) + * ``` + * + * @param stringExpressions The string expressions to concatenate. + * @return A new [Expression] representing the concatenated string. + */ + +public final com.google.firebase.firestore.pipeline.Expression stringConcat(com.google.firebase.firestore.pipeline.Expression... stringExpressions) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that concatenates this string expression with string constants. + * + * ```kotlin + * // Combine the 'firstName', " ", and 'lastName' fields into a single string + * field("firstName").stringConcat(" ", "lastName") + * ``` + * + * @param strings The string constants to concatenate. + * @return A new [Expression] representing the concatenated string. + */ + +public final com.google.firebase.firestore.pipeline.Expression stringConcat(java.lang.String... strings) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that concatenates string expressions and string constants together. + * + * ```kotlin + * // Combine the 'firstName', " ", and 'lastName' fields into a single string + * field("firstName").stringConcat(" ", field("lastName")) + * ``` + * + * @param strings The string expressions or string constants to concatenate. + * @return A new [Expression] representing the concatenated string. + */ + +public final com.google.firebase.firestore.pipeline.Expression stringConcat(java.lang.Object... strings) { throw new RuntimeException("Stub!"); } + +/** + * Accesses a map (object) value using the provided [keyExpression]. + * + * ```kotlin + * // Get the value from the 'address' map field, using the key from the 'keyField' field + * field("address").mapGet(field("keyField")) + * ``` + * + * @param keyExpression The name of the key to remove from this map expression. + * @return A new [Expression] representing the value associated with the given key in the map. + */ + +public final com.google.firebase.firestore.pipeline.Expression mapGet(com.google.firebase.firestore.pipeline.Expression keyExpression) { throw new RuntimeException("Stub!"); } + +/** + * Accesses a map (object) value using the provided [key]. + * + * ```kotlin + * // Get the 'city' value from the 'address' map field + * field("address").mapGet("city") + * ``` + * + * @param key The key to access in the map. + * @return A new [Expression] representing the value associated with the given key in the map. + */ + +public final com.google.firebase.firestore.pipeline.Expression mapGet(java.lang.String key) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that merges multiple maps into a single map. If multiple maps have the + * same key, the later value is used. + * + * ```kotlin + * // Merges the map in the settings field with, a map literal, and a map in + * // that is conditionally returned by another expression + * field("settings").mapMerge( + * map(mapOf("enabled" to true)), + * conditional( + * field("isAdmin").equal(true), + * map(mapOf("admin" to true)), + * map(emptyMap()) + * ) + * ) + * ``` + * + * @param mapExpr Map expression that will be merged. + * @param otherMaps Additional maps to merge. + * @return A new [Expression] representing the mapMerge operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression mapMerge(com.google.firebase.firestore.pipeline.Expression mapExpr, com.google.firebase.firestore.pipeline.Expression... otherMaps) { throw new RuntimeException("Stub!"); } + +/** + * Accesses a field/property of a document or Map using the provided [key]. + * + * @param key The string key to access. + * @return A new [Expression] representing the value of the field. + */ + +public final com.google.firebase.firestore.pipeline.Expression getField(java.lang.String key) { throw new RuntimeException("Stub!"); } + +/** + * Accesses a field/property of a document or Map using the provided [keyExpression]. + * + * @param keyExpression The expression evaluating to the key to access. + * @return A new [Expression] representing the value of the field. + */ + +public final com.google.firebase.firestore.pipeline.Expression getField(com.google.firebase.firestore.pipeline.Expression keyExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes a key from this map expression. + * + * ```kotlin + * // Removes the key 'baz' from the input map. + * map(mapOf("foo" to "bar", "baz" to true)).mapRemove(constant("baz")) + * ``` + * + * @param keyExpression The name of the key to remove from this map expression. + * @return A new [Expression] that evaluates to a modified map. + */ + +public final com.google.firebase.firestore.pipeline.Expression mapRemove(com.google.firebase.firestore.pipeline.Expression keyExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes a key from this map expression. + * + * ```kotlin + * // Removes the key 'baz' from the input map. + * map(mapOf("foo" to "bar", "baz" to true)).mapRemove("baz") + * ``` + * + * @param key The name of the key to remove from this map expression. + * @return A new [Expression] that evaluates to a modified map. + */ + +public final com.google.firebase.firestore.pipeline.Expression mapRemove(java.lang.String key) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a new map with the specified entries added or updated. + * + * - Only performs shallow updates to the map. + * - Setting a value to `null` will retain the key with a `null` value. To remove a key entirely, + * use `mapRemove`. + * + * ```kotlin + * // Set the 'category' key to the value of the 'newCategory' field. + * field("metadata").mapSet(field("keyField"), field("newCategory")) + * ``` + * + * @param key The key to set. + * @param value The value to set. + * @param moreKeyValues Additional key-value pairs to set. + * @return A new [Expression] representing the map with the entries set. + */ + +public final com.google.firebase.firestore.pipeline.Expression mapSet(com.google.firebase.firestore.pipeline.Expression key, com.google.firebase.firestore.pipeline.Expression value, com.google.firebase.firestore.pipeline.Expression... moreKeyValues) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a new map with the specified entries added or updated. + * + * ```kotlin + * // Set the 'category' key to "Electronics" and 'active' to true. + * field("metadata").mapSet("category", "Electronics", "active", true) + * ``` + * + * @param key The key to set. + * @param value The value to set. + * @param moreKeyValues Additional key-value pairs to set. + * @return A new [Expression] representing the map with the entries set. + */ + +public final com.google.firebase.firestore.pipeline.Expression mapSet(java.lang.String key, java.lang.Object value, java.lang.Object... moreKeyValues) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the keys of this map expression. + * + * While the backend generally preserves insertion order, relying on the order of the output array + * is not guaranteed and should be avoided. + * + * ```kotlin + * // Get the keys of the 'metadata' map field. + * field("metadata").mapKeys() + * ``` + * + * @return A new [Expression] representing the keys of the map. + */ + +public final com.google.firebase.firestore.pipeline.Expression mapKeys() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the values of this map expression. + * + * While the backend generally preserves insertion order, relying on the order of the output array + * is not guaranteed and should be avoided. + * + * ```kotlin + * // Get the values of the 'metadata' map field. + * field("metadata").mapValues() + * ``` + * + * @return A new [Expression] representing the values of the map. + */ + +public final com.google.firebase.firestore.pipeline.Expression mapValues() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the entries of this map expression as an array of maps, + * where each map contains a "k" property for the key and a "v" property for the value. + * + * While the backend generally preserves insertion order, relying on the order of the output array + * is not guaranteed and should be avoided. + * + * ```kotlin + * // Get the entries of the 'metadata' map field. + * field("metadata").mapEntries() + * ``` + * + * @return A new [Expression] representing the entries of the map. + */ + +public final com.google.firebase.firestore.pipeline.Expression mapEntries() { throw new RuntimeException("Stub!"); } + +/** + * Calculates the Cosine distance between this and another vector expressions. + * + * ```kotlin + * // Calculate the cosine distance between the 'userVector' field and the 'itemVector' field + * field("userVector").cosineDistance(field("itemVector")) + * ``` + * + * @param vector The other vector (represented as an Expression) to compare against. + * @return A new [Expression] representing the cosine distance between the two vectors. + */ + +public final com.google.firebase.firestore.pipeline.Expression cosineDistance(com.google.firebase.firestore.pipeline.Expression vector) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the Cosine distance between this vector expression and a vector literal. + * + * ```kotlin + * // Calculate the Cosine distance between the 'location' field and a target location + * field("location").cosineDistance(doubleArrayOf(37.7749, -122.4194)) + * ``` + * + * @param vector The other vector (as an array of doubles) to compare against. + * @return A new [Expression] representing the cosine distance between the two vectors. + */ + +public final com.google.firebase.firestore.pipeline.Expression cosineDistance(double[] vector) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the Cosine distance between this vector expression and a vector literal. + * + * ```kotlin + * // Calculate the Cosine distance between the 'location' field and a target location + * field("location").cosineDistance(VectorValue.from(listOf(37.7749, -122.4194))) + * ``` + * + * @param vector The other vector (represented as an [VectorValue]) to compare against. + * @return A new [Expression] representing the cosine distance between the two vectors. + */ + +public final com.google.firebase.firestore.pipeline.Expression cosineDistance(com.google.firebase.firestore.VectorValue vector) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the dot product distance between this and another vector expression. + * + * ```kotlin + * // Calculate the dot product between the 'userVector' field and the 'itemVector' field + * field("userVector").dotProduct(field("itemVector")) + * ``` + * + * @param vector The other vector (represented as an Expression) to compare against. + * @return A new [Expression] representing the dot product distance between the two vectors. + */ + +public final com.google.firebase.firestore.pipeline.Expression dotProduct(com.google.firebase.firestore.pipeline.Expression vector) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the dot product distance between this vector expression and a vector literal. + * + * ```kotlin + * // Calculate the dot product between the 'vector' field and a constant vector + * field("vector").dotProduct(doubleArrayOf(1.0, 2.0, 3.0)) + * ``` + * + * @param vector The other vector (as an array of doubles) to compare against. + * @return A new [Expression] representing the dot product distance between the two vectors. + */ + +public final com.google.firebase.firestore.pipeline.Expression dotProduct(double[] vector) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the dot product distance between this vector expression and a vector literal. + * + * ```kotlin + * // Calculate the dot product between the 'vector' field and a constant vector + * field("vector").dotProduct(VectorValue.from(listOf(1.0, 2.0, 3.0))) + * ``` + * + * @param vector The other vector (represented as an [VectorValue]) to compare against. + * @return A new [Expression] representing the dot product distance between the two vectors. + */ + +public final com.google.firebase.firestore.pipeline.Expression dotProduct(com.google.firebase.firestore.VectorValue vector) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the Euclidean distance between this and another vector expression. + * + * ```kotlin + * // Calculate the Euclidean distance between the 'userVector' field and the 'itemVector' field + * field("userVector").euclideanDistance(field("itemVector")) + * ``` + * + * @param vector The other vector (represented as an Expression) to compare against. + * @return A new [Expression] representing the Euclidean distance between the two vectors. + */ + +public final com.google.firebase.firestore.pipeline.Expression euclideanDistance(com.google.firebase.firestore.pipeline.Expression vector) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the Euclidean distance between this vector expression and a vector literal. + * + * ```kotlin + * // Calculate the Euclidean distance between the 'vector' field and a constant vector + * field("vector").euclideanDistance(doubleArrayOf(1.0, 2.0, 3.0)) + * ``` + * + * @param vector The other vector (as an array of doubles) to compare against. + * @return A new [Expression] representing the Euclidean distance between the two vectors. + */ + +public final com.google.firebase.firestore.pipeline.Expression euclideanDistance(double[] vector) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the Euclidean distance between this vector expression and a vector literal. + * + * ```kotlin + * // Calculate the Euclidean distance between the 'vector' field and a constant vector + * field("vector").euclideanDistance(VectorValue.from(listOf(1.0, 2.0, 3.0))) + * ``` + * + * @param vector The other vector (represented as an [VectorValue]) to compare against. + * @return A new [Expression] representing the Euclidean distance between the two vectors. + */ + +public final com.google.firebase.firestore.pipeline.Expression euclideanDistance(com.google.firebase.firestore.VectorValue vector) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the length (dimension) of a Firestore Vector. + * + * ```kotlin + * // Get the vector length (dimension) of the field 'embedding'. + * field("embedding").vectorLength() + * ``` + * + * @return A new [Expression] representing the length (dimension) of the vector. + */ + +public final com.google.firebase.firestore.pipeline.Expression vectorLength() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that interprets this expression as the number of microseconds since the + * Unix epoch (1970-01-01 00:00:00 UTC) and returns a timestamp. + * + * ```kotlin + * // Interpret the 'microseconds' field as microseconds since epoch. + * field("microseconds").unixMicrosToTimestamp() + * ``` + * + * @return A new [Expression] representing the timestamp. + */ + +public final com.google.firebase.firestore.pipeline.Expression unixMicrosToTimestamp() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that converts this timestamp expression to the number of microseconds + * since the Unix epoch (1970-01-01 00:00:00 UTC). + * + * ```kotlin + * // Convert the 'timestamp' field to microseconds since epoch. + * field("timestamp").timestampToUnixMicros() + * ``` + * + * @return A new [Expression] representing the number of microseconds since epoch. + */ + +public final com.google.firebase.firestore.pipeline.Expression timestampToUnixMicros() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that interprets this expression as the number of milliseconds since the + * Unix epoch (1970-01-01 00:00:00 UTC) and returns a timestamp. + * + * ```kotlin + * // Interpret the 'milliseconds' field as milliseconds since epoch. + * field("milliseconds").unixMillisToTimestamp() + * ``` + * + * @return A new [Expression] representing the timestamp. + */ + +public final com.google.firebase.firestore.pipeline.Expression unixMillisToTimestamp() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that converts this timestamp expression to the number of milliseconds + * since the Unix epoch (1970-01-01 00:00:00 UTC). + * + * ```kotlin + * // Convert the 'timestamp' field to milliseconds since epoch. + * field("timestamp").timestampToUnixMillis() + * ``` + * + * @return A new [Expression] representing the number of milliseconds since epoch. + */ + +public final com.google.firebase.firestore.pipeline.Expression timestampToUnixMillis() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that interprets this expression as the number of seconds since the Unix + * epoch (1970-01-01 00:00:00 UTC) and returns a timestamp. + * + * ```kotlin + * // Interpret the 'seconds' field as seconds since epoch. + * field("seconds").unixSecondsToTimestamp() + * ``` + * + * @return A new [Expression] representing the timestamp. + */ + +public final com.google.firebase.firestore.pipeline.Expression unixSecondsToTimestamp() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that converts this timestamp expression to the number of seconds since + * the Unix epoch (1970-01-01 00:00:00 UTC). + * + * ```kotlin + * // Convert the 'timestamp' field to seconds since epoch. + * field("timestamp").timestampToUnixSeconds() + * ``` + * + * @return A new [Expression] representing the number of seconds since epoch. + */ + +public final com.google.firebase.firestore.pipeline.Expression timestampToUnixSeconds() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that adds a specified amount of time to this timestamp expression. + * + * ```kotlin + * // Add some duration determined by field 'unit' and 'amount' to the 'timestamp' field. + * field("timestamp").timestampAdd(field("unit"), field("amount")) + * ``` + * + * @param unit The expression representing the unit of time to add. Valid units include + * "microsecond", "millisecond", "second", "minute", "hour" and "day". + * @param amount The expression representing the amount of time to add. + * @return A new [Expression] representing the resulting timestamp. + */ + +public final com.google.firebase.firestore.pipeline.Expression timestampAdd(com.google.firebase.firestore.pipeline.Expression unit, com.google.firebase.firestore.pipeline.Expression amount) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that adds a specified amount of time to this timestamp expression. + * + * ```kotlin + * // Add 1 day to the 'timestamp' field. + * field("timestamp").timestampAdd("day", 1) + * ``` + * + * @param unit The unit of time to add. Valid units include "microsecond", "millisecond", + * "second", "minute", "hour" and "day". + * @param amount The amount of time to add. + * @return A new [Expression] representing the resulting timestamp. + */ + +public final com.google.firebase.firestore.pipeline.Expression timestampAdd(java.lang.String unit, long amount) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates this timestamp expression to a specified granularity. + * + * ```kotlin + * // Truncate the 'createdAt' timestamp to the beginning of the day. + * field("createdAt").timestampTruncate("day") + * ``` + * + * @param granularity The granularity to truncate to. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @return A new [Expression] representing the truncated timestamp. + */ + +public final com.google.firebase.firestore.pipeline.Expression timestampTruncate(java.lang.String granularity) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates this timestamp expression to a specified granularity. + * + * ```kotlin + * // Truncate the 'createdAt' timestamp to the beginning of the day. + * field("createdAt").timestampTruncate(field("granularity")) + * ``` + * + * @param granularity The granularity expression to truncate to. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @return A new [Expression] representing the truncated timestamp. + */ + +public final com.google.firebase.firestore.pipeline.Expression timestampTruncate(com.google.firebase.firestore.pipeline.Expression granularity) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates this timestamp expression to a specified granularity in a + * given timezone. + * + * ```kotlin + * // Truncate the 'createdAt' timestamp to the beginning of the day in "America/Los_Angeles" + * // timezone. + * field("createdAt").timestampTruncateWithTimezone("day", "America/Los_Angeles") + * ``` + * + * @param granularity The granularity to truncate to. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone to use for truncation. Valid values are from the TZ database + * (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". + * @return A new [Expression] representing the truncated timestamp. + */ + +public final com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(java.lang.String granularity, java.lang.String timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates this timestamp expression to a specified granularity in a + * given timezone. + * + * ```kotlin + * // Truncate the 'createdAt' timestamp to the beginning of the day in "America/Los_Angeles" + * // timezone. + * field("createdAt").timestampTruncateWithTimezone(field("granularity"), "America/Los_Angeles") + * ``` + * + * @param granularity The granularity expression to truncate to. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone to use for truncation. Valid values are from the TZ database + * (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". + * @return A new [Expression] representing the truncated timestamp. + */ + +public final com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(com.google.firebase.firestore.pipeline.Expression granularity, java.lang.String timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates this timestamp expression to a specified granularity in a + * given timezone. + * + * ```kotlin + * // Truncate the 'createdAt' timestamp to the beginning of the day in timezone specified by the + * // 'tz' field. + * field("createdAt").timestampTruncateWithTimezone("day", field("tz")) + * ``` + * + * @param granularity The granularity to truncate to. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone expression to use for truncation. Valid values are from the TZ + * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". + * @return A new [Expression] representing the truncated timestamp. + */ + +public final com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(java.lang.String granularity, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates this timestamp expression to a specified granularity in a + * given timezone. + * + * ```kotlin + * // Truncate the 'createdAt' timestamp to the beginning of the day in timezone specified by the + * // 'tz' field. + * field("createdAt").timestampTruncateWithTimezone(field("granularity"), field("tz")) + * ``` + * + * @param granularity The granularity expression to truncate to. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone expression to use for truncation. Valid values are from the TZ + * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". + * @return A new [Expression] representing the truncated timestamp. + */ + +public final com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(com.google.firebase.firestore.pipeline.Expression granularity, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the difference between this timestamp and another timestamp. + * + * ```kotlin + * // Calculate the difference determined by fields 'startAt' and 'unit'. + * field("endAt").timestampDiff(field("startAt"), field("unit")) + * ``` + * + * @param start The starting timestamp expression. + * @param unit The unit of time for the difference. Valid values include "microsecond", + * "millisecond", "second", "minute", "hour" and "day". + * @return A new [Expression] representing the difference. + */ + +public final com.google.firebase.firestore.pipeline.Expression timestampDiff(com.google.firebase.firestore.pipeline.Expression start, com.google.firebase.firestore.pipeline.Expression unit) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the difference between this timestamp and another timestamp. + * + * ```kotlin + * // Calculate the difference in days between 'endAt' and 'startAt' fields. + * field("endAt").timestampDiff(field("startAt"), "day") + * ``` + * + * @param start The starting timestamp expression. + * @param unit The unit of time for the difference. Valid values include "microsecond", + * "millisecond", "second", "minute", "hour" and "day". + * @return A new [Expression] representing the difference. + */ + +public final com.google.firebase.firestore.pipeline.Expression timestampDiff(com.google.firebase.firestore.pipeline.Expression start, java.lang.String unit) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the difference between this timestamp and another timestamp. + * + * ```kotlin + * // Calculate the difference in days between 'endAt' and 'startAt' fields. + * field("endAt").timestampDiff("startAt", "day") + * ``` + * + * @param startFieldName The starting timestamp field name. + * @param unit The unit of time for the difference. Valid values include "microsecond", + * "millisecond", "second", "minute", "hour" and "day". + * @return A new [Expression] representing the difference. + */ + +public final com.google.firebase.firestore.pipeline.Expression timestampDiff(java.lang.String startFieldName, java.lang.String unit) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that extracts a specified part from this timestamp expression. + * + * ```kotlin + * // Extract the part specified by the field 'part' from 'timestamp'. + * field("timestamp").timestampExtract(field("part")) + * ``` + * + * @param part The part to extract. Valid values are "microsecond", "millisecond", "second", + * "minute", "hour", "dayofweek", "day", "dayofyear", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @return A new [Expression] representing the extracted part. + */ + +public final com.google.firebase.firestore.pipeline.Expression timestampExtract(com.google.firebase.firestore.pipeline.Expression part) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that extracts a specified part from this timestamp expression. + * + * ```kotlin + * // Extract the day from the timestamp in the 'timestamp' field. + * field("timestamp").timestampExtract("day") + * ``` + * + * @param part The part to extract. Valid values are "microsecond", "millisecond", "second", + * "minute", "hour", "dayofweek", "day", "dayofyear", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @return A new [Expression] representing the extracted part. + */ + +public final com.google.firebase.firestore.pipeline.Expression timestampExtract(java.lang.String part) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that extracts a specified part from this timestamp expression in a given + * timezone. + * + * ```kotlin + * // Extract the part specified by the field 'part' from 'timestamp' in timezone 'America/Los_Angeles'. + * field("timestamp").timestampExtractWithTimezone(field("part"), "America/Los_Angeles") + * ``` + * + * @param part The part to extract. Valid values are "microsecond", "millisecond", "second", + * "minute", "hour", "dayofweek", "day", "dayofyear", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone to use for extraction. Valid values are from the TZ database + * (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not specified. + * @return A new [Expression] representing the extracted part. + */ + +public final com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(com.google.firebase.firestore.pipeline.Expression part, java.lang.String timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that extracts a specified part from this timestamp expression in a given + * timezone. + * + * ```kotlin + * // Extract the day from the timestamp in the 'timestamp' field in timezone 'America/Los_Angeles'. + * field("timestamp").timestampExtractWithTimezone("day", "America/Los_Angeles") + * ``` + * + * @param part The part to extract. Valid values are "microsecond", "millisecond", "second", + * "minute", "hour", "dayofweek", "day", "dayofyear", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone to use for extraction. Valid values are from the TZ database + * (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not specified. + * @return A new [Expression] representing the extracted part. + */ + +public final com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(java.lang.String part, java.lang.String timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that extracts a specified part from this timestamp expression in a given + * timezone. + * + * ```kotlin + * // Extract the part specified by the field 'part' from 'timestamp' in timezone specified by + * the field 'tz'. + * field("timestamp").timestampExtractWithTimezone(field("part"), field("tz")) + * ``` + * + * @param part The part to extract. Valid values are "microsecond", "millisecond", "second", + * "minute", "hour", "dayofweek", "day", "dayofyear", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone expression to use for extraction. Valid values are from the TZ + * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not + * specified. + * @return A new [Expression] representing the extracted part. + */ + +public final com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(com.google.firebase.firestore.pipeline.Expression part, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that extracts a specified part from this timestamp expression in a given + * timezone. + * + * ```kotlin + * // Extract the day from the timestamp in the 'timestamp' field in timezone specified by + * the field 'tz'. + * field("timestamp").timestampExtractWithTimezone("day", field("tz")) + * ``` + * + * @param part The part to extract. Valid values are "microsecond", "millisecond", "second", + * "minute", "hour", "dayofweek", "day", "dayofyear", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone expression to use for extraction. Valid values are from the TZ + * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not + * specified. + * @return A new [Expression] representing the extracted part. + */ + +public final com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(java.lang.String part, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that subtracts a specified amount of time to this timestamp expression. + * + * ```kotlin + * // Subtract some duration determined by field 'unit' and 'amount' from the 'timestamp' field. + * field("timestamp").timestampSubtract(field("unit"), field("amount")) + * ``` + * + * @param unit The expression representing the unit of time to subtract. Valid units include + * "microsecond", "millisecond", "second", "minute", "hour" and "day". + * @param amount The expression representing the amount of time to subtract. + * @return A new [Expression] representing the resulting timestamp. + */ + +public final com.google.firebase.firestore.pipeline.Expression timestampSubtract(com.google.firebase.firestore.pipeline.Expression unit, com.google.firebase.firestore.pipeline.Expression amount) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that subtracts a specified amount of time to this timestamp expression. + * + * ```kotlin + * // Subtract 1 day from the 'timestamp' field. + * field("timestamp").timestampSubtract("day", 1) + * ``` + * + * @param unit The unit of time to subtract. Valid units include "microsecond", "millisecond", + * "second", "minute", "hour" and "day". + * @param amount The amount of time to subtract. + * @return A new [Expression] representing the resulting timestamp. + */ + +public final com.google.firebase.firestore.pipeline.Expression timestampSubtract(java.lang.String unit, long amount) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that concatenates this expression's value with others. The values must be + * all strings, all arrays, or all blobs. Types cannot be mixed. + * + * ```kotlin + * // Concatenate a field with another field. + * field("firstName").concat(field("lastName")) + * ``` + * + * @param second The second expression to concatenate. + * @param others Additional expressions to concatenate. + * @return A new [Expression] representing the concatenation. + */ + +public final com.google.firebase.firestore.pipeline.Expression concat(com.google.firebase.firestore.pipeline.Expression second, java.lang.Object... others) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that concatenates this expression's value with others. The values must be + * all strings, all arrays, or all blobs. Types cannot be mixed. + * + * ```kotlin + * // Concatenate a field with a literal string. + * field("firstName").concat("lastName") + * ``` + * + * @param second The second value to concatenate. + * @param others Additional values to concatenate. + * @return A new [Expression] representing the concatenation. + */ + +public final com.google.firebase.firestore.pipeline.Expression concat(java.lang.Object second, java.lang.Object... others) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that concatenates a field's array value with other arrays. + * + * ```kotlin + * // Combine the 'items' array with another array field. + * field("items").arrayConcat(field("otherItems")) + * ``` + * + * @param secondArray An expression that evaluates to array to concatenate. + * @param otherArrays Optional additional array expressions or array literals to concatenate. + * @return A new [Expression] representing the arrayConcat operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression arrayConcat(com.google.firebase.firestore.pipeline.Expression secondArray, java.lang.Object... otherArrays) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that concatenates a field's array value with other arrays. + * + * ```kotlin + * // Combine the 'items' array with a literal array. + * field("items").arrayConcat(listOf("a", "b")) + * ``` + * + * @param secondArray An array expression or array literal to concatenate. + * @param otherArrays Optional additional array expressions or array literals to concatenate. + * @return A new [Expression] representing the arrayConcat operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression arrayConcat(java.lang.Object secondArray, java.lang.Object... otherArrays) { throw new RuntimeException("Stub!"); } + +/** + * Reverses the order of elements in the array. + * + * ```kotlin + * // Reverse the value of the 'myArray' field. + * field("myArray").arrayReverse() + * ``` + * + * @return A new [Expression] representing the arrayReverse operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression arrayReverse() { throw new RuntimeException("Stub!"); } + +/** + * Filters this array expression based on a predicate. + * + * ```kotlin + * // Filter 'scores' array to include only values greater than 50 + * field("scores").arrayFilter("score", greaterThan(variable("score"), 50)) + * ``` + * + * @param alias The alias to use for the current element in the filter expression. + * @param filter The predicate boolean expression used to filter the elements. + * @return A new [Expression] representing the arrayFilter operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression arrayFilter(java.lang.String alias, com.google.firebase.firestore.pipeline.BooleanExpression filter) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a provided transformation to each element in an array. + * + * ```kotlin + * // Transform 'scores' array by multiplying each score by 10 + * field("scores").arrayTransform("score", multiply(variable("score"), 10)) + * ``` + * + * @param elementAlias The alias to use for the current element in the transform expression. + * @param transform The expression used to transform the elements. + * @return A new [Expression] representing the arrayTransform operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression arrayTransform(java.lang.String elementAlias, com.google.firebase.firestore.pipeline.Expression transform) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a provided transformation to each element in an array, + * providing the element's index to the transformation expression. + * + * ```kotlin + * // Transform 'scores' array by adding the index + * field("scores").arrayTransformWithIndex("score", "i", add(variable("score"), variable("i"))) + * ``` + * + * @param elementAlias The alias to use for the current element in the transform expression. + * @param indexAlias The alias to use for the current index. + * @param transform The expression used to transform the elements. + * @return A new [Expression] representing the arrayTransformWithIndex operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression arrayTransformWithIndex(java.lang.String elementAlias, java.lang.String indexAlias, com.google.firebase.firestore.pipeline.Expression transform) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a slice of this array expression to its end. + * + * ```kotlin + * // Get elements from the 'items' array starting from index 2 + * field("items").arraySliceToEnd(2) + * ``` + * + * @param offset The starting index. + * @return A new [Expression] representing the arraySliceToEnd operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression arraySliceToEnd(int offset) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a slice of this array expression to its end. + * + * ```kotlin + * // Get elements from the 'items' array starting from the value of the 'offset' field + * field("items").arraySliceToEnd(field("offset")) + * ``` + * + * @param offset The starting index. + * @return A new [Expression] representing the arraySliceToEnd operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression arraySliceToEnd(com.google.firebase.firestore.pipeline.Expression offset) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a slice of this array expression. + * + * ```kotlin + * // Get 5 elements from the 'items' array starting from index 2 + * field("items").arraySlice(2, 5) + * ``` + * + * @param offset The starting index. + * @param length The number of elements to return. + * @return A new [Expression] representing the arraySlice operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression arraySlice(int offset, int length) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a slice of this array expression. + * + * ```kotlin + * // Get elements from the 'items' array using expressions for offset and length + * field("items").arraySlice(field("offset"), field("length")) + * ``` + * + * @param offset The starting index. + * @param length The number of elements to return. + * @return A new [Expression] representing the arraySlice operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression arraySlice(com.google.firebase.firestore.pipeline.Expression offset, com.google.firebase.firestore.pipeline.Expression length) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the sum of the elements in this array expression. + * + * ```kotlin + * // Get the sum of elements in the 'scores' array. + * field("scores").arraySum() + * ``` + * + * @return A new [Expression] representing the sum of the array elements. + */ + +public final com.google.firebase.firestore.pipeline.Expression arraySum() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if array contains a specific [element]. + * + * ```kotlin + * // Check if the 'sizes' array contains the value from the 'selectedSize' field + * field("sizes").arrayContains(field("selectedSize")) + * ``` + * + * @param element The element to search for in the array. + * @return A new [BooleanExpression] representing the arrayContains operation. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression arrayContains(com.google.firebase.firestore.pipeline.Expression element) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if array contains a specific [element]. + * + * ```kotlin + * // Check if the 'colors' array contains "red" + * field("colors").arrayContains("red") + * ``` + * + * @param element The element to search for in the array. + * @return A new [BooleanExpression] representing the arrayContains operation. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression arrayContains(java.lang.Object element) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if array contains all the specified [values]. + * + * ```kotlin + * // Check if the 'tags' array contains both the value in field "tag1" and the literal value "tag2" + * field("tags").arrayContainsAll(listOf(field("tag1"), "tag2")) + * ``` + * + * @param values The elements to check for in the array. + * @return A new [BooleanExpression] representing the arrayContainsAll operation. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAll(java.util.List values) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if array contains all elements of [arrayExpression]. + * + * ```kotlin + * // Check if the 'tags' array contains both of the values from field "tag1" and the literal value "tag2" + * field("tags").arrayContainsAll(array(field("tag1"), "tag2")) + * ``` + * + * @param arrayExpression The elements to check for in the array. + * @return A new [BooleanExpression] representing the arrayContainsAll operation. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAll(com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if array contains any of the specified [values]. + * + * ```kotlin + * // Check if the 'categories' array contains either values from field "cate1" or "cate2" + * field("categories").arrayContainsAny(listOf(field("cate1"), field("cate2"))) + * ``` + * + * @param values The elements to check for in the array. + * @return A new [BooleanExpression] representing the arrayContainsAny operation. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAny(java.util.List values) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if array contains any elements of [arrayExpression]. + * + * ```kotlin + * // Check if the 'groups' array contains either the value from the 'userGroup' field + * // or the value "guest" + * field("groups").arrayContainsAny(array(field("userGroup"), "guest")) + * ``` + * + * @param arrayExpression The elements to check for in the array. + * @return A new [BooleanExpression] representing the arrayContainsAny operation. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAny(com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the length of an array expression. + * + * ```kotlin + * // Get the number of items in the 'cart' array + * field("cart").arrayLength() + * ``` + * + * @return A new [Expression] representing the length of the array. + */ + +public final com.google.firebase.firestore.pipeline.Expression arrayLength() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first element of an array expression. + * + * ```kotlin + * // Get the first element of the 'myArray' field. + * field("myArray").arrayFirst() + * ``` + * + * @return A new [Expression] representing the first element. + */ + +public final com.google.firebase.firestore.pipeline.Expression arrayFirst() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first N elements of an array expression. + * + * ```kotlin + * // Get the first 2 elements of the 'myArray' field. + * field("myArray").arrayFirstN(2) + * ``` + * + * @param n The number of elements to return. + * @return A new [Expression] representing the first N elements. + */ + +public final com.google.firebase.firestore.pipeline.Expression arrayFirstN(int n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first N elements of an array expression. + * + * ```kotlin + * // Get the first 2 elements of the 'myArray' field. + * field("myArray").arrayFirstN(2) + * ``` + * + * @param n The number of elements to return. + * @return A new [Expression] representing the first N elements. + */ + +public final com.google.firebase.firestore.pipeline.Expression arrayFirstN(com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the last element of an array expression. + * + * ```kotlin + * // Get the last element of the 'myArray' field. + * field("myArray").arrayLast() + * ``` + * + * @return A new [Expression] representing the last element. + */ + +public final com.google.firebase.firestore.pipeline.Expression arrayLast() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the last N elements of an array expression. + * + * ```kotlin + * // Get the last 2 elements of the 'myArray' field. + * field("myArray").arrayLastN(2) + * ``` + * + * @param n The number of elements to return. + * @return A new [Expression] representing the last N elements. + */ + +public final com.google.firebase.firestore.pipeline.Expression arrayLastN(int n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the last N elements of an array expression. + * + * ```kotlin + * // Get the last 2 elements of the 'myArray' field. + * field("myArray").arrayLastN(2) + * ``` + * + * @param n The number of elements to return. + * @return A new [Expression] representing the last N elements. + */ + +public final com.google.firebase.firestore.pipeline.Expression arrayLastN(com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the minimum value of an array expression. + * + * ```kotlin + * // Get the minimum value of the 'myArray' field. + * field("myArray").arrayMinimum() + * ``` + * + * @return A new [Expression] representing the minimum value. + */ + +public final com.google.firebase.firestore.pipeline.Expression arrayMinimum() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the maximum value of an array expression. + * + * ```kotlin + * // Get the maximum value of the 'myArray' field. + * field("myArray").arrayMaximum() + * ``` + * + * @return A new [Expression] representing the maximum value. + */ + +public final com.google.firebase.firestore.pipeline.Expression arrayMaximum() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first `n` smallest elements of the [array]. + * + * Note: Returns the n smallest non-null elements in the array, in ascending order. This does not + * use a stable sort, meaning the order of equivalent elements is undefined. + * + * ```kotlin + * // Get the 3 smallest elements of the 'myArray' field. + * field("myArray").arrayMinimumN(3) + * ``` + * + * @param n The number of elements to return. + * @return A new [Expression] representing the first `n` smallest elements. + */ + +public final com.google.firebase.firestore.pipeline.Expression arrayMinimumN(int n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first `n` smallest elements of the [array]. + * + * Note: Returns the n smallest non-null elements in the array, in ascending order. This does not + * use a stable sort, meaning the order of equivalent elements is undefined. + * + * ```kotlin + * // Get the n smallest elements of the 'myArray' field. + * field("myArray").arrayMinimumN(field("count")) + * ``` + * + * @param n An expression evaluating to the number of elements to return. + * @return A new [Expression] representing the first `n` smallest elements. + */ + +public final com.google.firebase.firestore.pipeline.Expression arrayMinimumN(com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first `n` largest elements of the [array]. + * + * Note: Returns the n largest non-null elements in the array, in descending order. This does not + * use a stable sort, meaning the order of equivalent elements is undefined. + * + * ```kotlin + * // Get the 3 largest elements of the 'myArray' field. + * field("myArray").arrayMaximumN(3) + * ``` + * + * @param n The number of elements to return. + * @return A new [Expression] representing the first `n` largest elements. + */ + +public final com.google.firebase.firestore.pipeline.Expression arrayMaximumN(int n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first `n` largest elements of the [array]. + * + * Note: Returns the n largest non-null elements in the array, in descending order. This does not + * use a stable sort, meaning the order of equivalent elements is undefined. + * + * ```kotlin + * // Get the n largest elements of the 'myArray' field. + * field("myArray").arrayMaximumN(field("count")) + * ``` + * + * @param n An expression evaluating to the number of elements to return. + * @return A new [Expression] representing the first `n` largest elements. + */ + +public final com.google.firebase.firestore.pipeline.Expression arrayMaximumN(com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first index where the specified [value] occurs in the + * [array]. + * + * ```kotlin + * // Get the first index of 'foo' in the 'tags' array field. + * field("tags").arrayIndexOf("foo") + * ``` + * + * @param value The value to search for. + * @return A new [Expression] representing the index of the value. + */ + +public final com.google.firebase.firestore.pipeline.Expression arrayIndexOf(java.lang.Object value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the last index where the specified [value] occurs in the + * [array]. + * + * ```kotlin + * // Get the last index of 'foo' in the 'tags' array field. + * field("tags").arrayLastIndexOf("foo") + * ``` + * + * @param value The value to search for. + * @return A new [Expression] representing the index of the value. + */ + +public final com.google.firebase.firestore.pipeline.Expression arrayLastIndexOf(java.lang.Object value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a list of all indices where the specified [value] occurs in + * the [array]. + * + * ```kotlin + * // Get all indices of 'foo' in the 'tags' array field. + * field("tags").arrayIndexOfAll("foo") + * ``` + * + * @param value The value to search for. + * @return A new [Expression] representing the list of indices. + */ + +public final com.google.firebase.firestore.pipeline.Expression arrayIndexOfAll(java.lang.Object value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that indexes into an array from the beginning or end and return the + * element. If the offset exceeds the array length, an error is returned. A negative offset, + * starts from the end. + * + * ```kotlin + * // Return the value in the tags field array at index specified by field 'favoriteTag'. + * field("tags").arrayGet(field("favoriteTag")) + * ``` + * + * @param offset An Expression evaluating to the index of the element to return. + * @return A new [Expression] representing the arrayOffset operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression arrayGet(com.google.firebase.firestore.pipeline.Expression offset) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that indexes into an array from the beginning or end and return the + * element. If the offset exceeds the array length, an error is returned. A negative offset, + * starts from the end. + * + * ```kotlin + * // Return the value in the 'tags' field array at index `1`. + * field("tags").arrayGet(1) + * ``` + * + * @param offset An Expression evaluating to the index of the element to return. + * @return A new [Expression] representing the arrayOffset operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression arrayGet(int offset) { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that counts the number of stage inputs with valid evaluations of the + * this expression. + * + * @return A new [AggregateFunction] representing the count aggregation. + */ + +public final com.google.firebase.firestore.pipeline.AggregateFunction count() { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that counts the number of distinct values of an expression across + * multiple stage inputs. + * + * @return A new [AggregateFunction] representing the count distinct aggregation. + */ + +public final com.google.firebase.firestore.pipeline.AggregateFunction countDistinct() { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that calculates the sum of this numeric expression across multiple stage + * inputs. + * + * @return A new [AggregateFunction] representing the sum aggregation. + */ + +public final com.google.firebase.firestore.pipeline.AggregateFunction sum() { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that calculates the average (mean) of this numeric expression across + * multiple stage inputs. + * + * @return A new [AggregateFunction] representing the average aggregation. + */ + +public final com.google.firebase.firestore.pipeline.AggregateFunction average() { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that finds the minimum value of this expression across multiple stage + * inputs. + * + * @return A new [AggregateFunction] representing the minimum aggregation. + */ + +public final com.google.firebase.firestore.pipeline.AggregateFunction minimum() { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that finds the maximum value of this expression across multiple stage + * inputs. + * + * @return A new [AggregateFunction] representing the maximum aggregation. + */ + +public final com.google.firebase.firestore.pipeline.AggregateFunction maximum() { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that finds the first value of this expression across multiple stage + * inputs. + * + * @return A new [AggregateFunction] representing the first aggregation. + */ + +public final com.google.firebase.firestore.pipeline.AggregateFunction first() { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that finds the last value of this expression across multiple stage + * inputs. + * + * @return A new [AggregateFunction] representing the last aggregation. + */ + +public final com.google.firebase.firestore.pipeline.AggregateFunction last() { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that collects all values of this expression across multiple stage inputs + * into an array. + * + * If the expression resolves to an absent value, it is converted to `null`. The order of elements + * in the output array is not stable and shouldn't be relied upon. + * + * @return A new [AggregateFunction] representing the array_agg aggregation. + */ + +public final com.google.firebase.firestore.pipeline.AggregateFunction arrayAgg() { throw new RuntimeException("Stub!"); } + +/** + * Creates an aggregation that collects all distinct values of this expression across multiple + * stage inputs into an array. + * + * If the expression resolves to an absent value, it is converted to `null`. The order of elements + * in the output array is not stable and shouldn't be relied upon. + * + * @return A new [AggregateFunction] representing the array_agg_distinct aggregation. + */ + +public final com.google.firebase.firestore.pipeline.AggregateFunction arrayAggDistinct() { throw new RuntimeException("Stub!"); } + +/** + * Create an [Ordering] that sorts documents in ascending order based on value of this expression + * + * @return A new [Ordering] object with ascending sort by this expression. + */ + +public final com.google.firebase.firestore.pipeline.Ordering ascending() { throw new RuntimeException("Stub!"); } + +/** + * Create an [Ordering] that sorts documents in descending order based on value of this expression + * + * @return A new [Ordering] object with descending sort by this expression. + */ + +public final com.google.firebase.firestore.pipeline.Ordering descending() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if this and [other] expression are equal. + * + * ```kotlin + * // Check if the 'age' field is equal to an expression + * field("age").equal(field("minAge").add(10)) + * ``` + * + * @param other The expression to compare to. + * @return A new [BooleanExpression] representing the equality comparison. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression equal(com.google.firebase.firestore.pipeline.Expression other) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if this expression is equal to a [value]. + * + * ```kotlin + * // Check if the 'age' field is equal to 21 + * field("age").equal(21) + * ``` + * + * @param value The value to compare to. + * @return A new [BooleanExpression] representing the equality comparison. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression equal(java.lang.Object value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if this expressions is not equal to the [other] expression. + * + * ```kotlin + * // Check if the 'status' field is not equal to the value of the 'otherStatus' field + * field("status").notEqual(field("otherStatus")) + * ``` + * + * @param other The expression to compare to. + * @return A new [BooleanExpression] representing the inequality comparison. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression notEqual(com.google.firebase.firestore.pipeline.Expression other) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if this expression is not equal to a [value]. + * + * ```kotlin + * // Check if the 'status' field is not equal to "completed" + * field("status").notEqual("completed") + * ``` + * + * @param value The value to compare to. + * @return A new [BooleanExpression] representing the inequality comparison. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression notEqual(java.lang.Object value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if this expression is greater than the [other] expression. + * + * ```kotlin + * // Check if the 'age' field is greater than the 'limit' field + * field("age").greaterThan(field("limit")) + * ``` + * + * @param other The expression to compare to. + * @return A new [BooleanExpression] representing the greater than comparison. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression greaterThan(com.google.firebase.firestore.pipeline.Expression other) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if this expression is greater than a [value]. + * + * ```kotlin + * // Check if the 'price' field is greater than 100 + * field("price").greaterThan(100) + * ``` + * + * @param value The value to compare to. + * @return A new [BooleanExpression] representing the greater than comparison. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression greaterThan(java.lang.Object value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if this expression is greater than or equal to the [other] + * expression. + * + * ```kotlin + * // Check if the 'quantity' field is greater than or equal to field 'requirement' plus 1 + * field("quantity").greaterThanOrEqual(field("requirement").add(1)) + * ``` + * + * @param other The expression to compare to. + * @return A new [BooleanExpression] representing the greater than or equal to comparison. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression greaterThanOrEqual(com.google.firebase.firestore.pipeline.Expression other) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if this expression is greater than or equal to a [value]. + * + * ```kotlin + * // Check if the 'score' field is greater than or equal to 80 + * field("score").greaterThanOrEqual(80) + * ``` + * + * @param value The value to compare to. + * @return A new [BooleanExpression] representing the greater than or equal to comparison. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression greaterThanOrEqual(java.lang.Object value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if this expression is less than the [other] expression. + * + * ```kotlin + * // Check if the 'age' field is less than 'limit' + * field("age").lessThan(field("limit")) + * ``` + * + * @param other The expression to compare to. + * @return A new [BooleanExpression] representing the less than comparison. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression lessThan(com.google.firebase.firestore.pipeline.Expression other) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if this expression is less than a value. + * + * ```kotlin + * // Check if the 'price' field is less than 50 + * field("price").lessThan(50) + * ``` + * + * @param value The value to compare to. + * @return A new [BooleanExpression] representing the less than comparison. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression lessThan(java.lang.Object value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if this expression is less than or equal to the [other] + * expression. + * + * ```kotlin + * // Check if the 'quantity' field is less than or equal to 20 + * field("quantity").lessThanOrEqual(constant(20)) + * ``` + * + * @param other The expression to compare to. + * @return A new [BooleanExpression] representing the less than or equal to comparison. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression lessThanOrEqual(com.google.firebase.firestore.pipeline.Expression other) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if this expression is less than or equal to a [value]. + * + * ```kotlin + * // Check if the 'score' field is less than or equal to 70 + * field("score").lessThanOrEqual(70) + * ``` + * + * @param value The value to compare to. + * @return A new [BooleanExpression] representing the less than or equal to comparison. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression lessThanOrEqual(java.lang.Object value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if this expression evaluates to a name of the field that + * exists. + * + * @return A new [Expression] representing the exists check. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression exists() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [catchExpr] argument if there is an error, else return + * the result of this expression. + * + * ```kotlin + * // Returns the first item in the title field arrays, or returns + * // the entire title field if the array is empty or the field is another type. + * arrayGet(field("title"), 0).ifError(field("title")) + * ``` + * + * @param catchExpr The catch expression that will be evaluated and returned if the this + * expression produces an error. + * @return A new [Expression] representing the ifError operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression ifError(com.google.firebase.firestore.pipeline.Expression catchExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [catchValue] argument if there is an error, else return + * the result of this expression. + * + * ```kotlin + * // Returns the first item in the title field arrays, or returns "Default Title" + * arrayGet(field("title"), 0).ifError("Default Title") + * ``` + * + * @param catchValue The value that will be returned if this expression produces an error. + * @return A new [Expression] representing the ifError operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression ifError(java.lang.Object catchValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [elseExpr] argument if this expression is absent, else + * return the result of this expression. + * + * ```kotlin + * // Returns the value of the optional field 'optional_field', or returns 'default_value' + * // if the field is absent. + * field("optional_field").ifAbsent("default_value") + * ``` + * + * @param elseExpr The expression that will be evaluated and returned if this expression is + * absent. + * @return A new [Expression] representing the ifAbsent operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression ifAbsent(com.google.firebase.firestore.pipeline.Expression elseExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [elseValue] argument if this expression is absent, else + * return the result of this expression. + * + * ```kotlin + * // Returns the value of the optional field 'optional_field', or returns 'default_value' + * // if the field is absent. + * field("optional_field").ifAbsent("default_value") + * ``` + * + * @param elseValue The value that will be returned if this expression is absent. + * @return A new [Expression] representing the ifAbsent operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression ifAbsent(java.lang.Object elseValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [elseExpression] argument if this expression evaluates + * to null, else return the result of this expression. + * + * This function provides a fallback for both absent and explicit null values. In contrast, + * [ifAbsent] only triggers for missing fields. + * + * ```kotlin + * // Returns the user's preferred name, or if that is null, returns their full name. + * field("preferredName").ifNull(field("fullName")) + * ``` + * + * @param elseExpression The expression that will be evaluated and returned if this expression is + * null. + * @return A new [Expression] representing the ifNull operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression ifNull(com.google.firebase.firestore.pipeline.Expression elseExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [elseValue] argument if this expression evaluates to + * null, else return the result of this expression. + * + * This function provides a fallback for both absent and explicit null values. In contrast, + * [ifAbsent] only triggers for missing fields. + * + * ```kotlin + * // Returns the user's display name, or returns "Anonymous" if the field is null. + * field("displayName").ifNull("Anonymous") + * ``` + * + * @param elseValue The value that will be returned if this expression evaluates to null. + * @return A new [Expression] representing the ifNull operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression ifNull(java.lang.Object elseValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first non-null, non-absent argument, without evaluating + * the rest of the arguments. When all arguments are null or absent, returns the last argument. + * + * ```kotlin + * // Returns the value of the first non-null, non-absent field among 'preferredName', 'fullName', + * // or the last argument if all previous fields are null. + * field("preferredName").coalesce(field("fullName"), "Anonymous") + * ``` + * + * @param replacement The fallback expression or value if the first one is null. + * @param others Optional additional expressions to check if previous ones are null. + * @return A new [Expression] representing the coalesce operation. + */ + +public final com.google.firebase.firestore.pipeline.Expression coalesce(java.lang.Object replacement, java.lang.Object... others) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if this expression produces an error. + * + * ```kotlin + * // Check if the result of a calculation is an error + * arrayContains(field("title"), 1).isError() + * ``` + * + * @return A new [BooleanExpression] representing the `isError` check. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression isError() { throw new RuntimeException("Stub!"); } + +/** + * Casts the expression to a [BooleanExpression]. + * + * @return A [BooleanExpression] representing the same expression. + */ + +public final com.google.firebase.firestore.pipeline.BooleanExpression asBoolean() { throw new RuntimeException("Stub!"); } + +/** + * Create a constant for a [String] value. + * + * ```kotlin + * // Create a constant with the value "hello" + * constant("hello") + * ``` + * + * @param value The [String] value. + * @return A new [Expression] constant instance. + */ + +public static final com.google.firebase.firestore.pipeline.Expression constant(java.lang.String value) { throw new RuntimeException("Stub!"); } + +/** + * Create a constant for a [Number] value. + * + * ```kotlin + * // Create a constant with the value 123 + * constant(123) + * ``` + * + * @param value The [Number] value. + * @return A new [Expression] constant instance. + */ + +public static final com.google.firebase.firestore.pipeline.Expression constant(java.lang.Number value) { throw new RuntimeException("Stub!"); } + +/** + * Create a constant for a [Date] value. + * + * ```kotlin + * // Create a constant with the current date + * constant(Date()) + * ``` + * + * @param value The [Date] value. + * @return A new [Expression] constant instance. + */ + +public static final com.google.firebase.firestore.pipeline.Expression constant(java.util.Date value) { throw new RuntimeException("Stub!"); } + +/** + * Create a constant for a [Timestamp] value. + * + * ```kotlin + * // Create a constant with the current timestamp + * constant(Timestamp.now()) + * ``` + * + * @param value The [Timestamp] value. + * @return A new [Expression] constant instance. + */ + +public static final com.google.firebase.firestore.pipeline.Expression constant(com.google.firebase.Timestamp value) { throw new RuntimeException("Stub!"); } + +/** + * Create a constant for a [Boolean] value. + * + * ```kotlin + * // Create a constant with the value true + * constant(true) + * ``` + * + * @param value The [Boolean] value. + * @return A new [BooleanExpression] constant instance. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression constant(boolean value) { throw new RuntimeException("Stub!"); } + +/** + * Create a constant for a [GeoPoint] value. + * + * ```kotlin + * // Create a constant with a GeoPoint + * constant(GeoPoint(37.7749, -122.4194)) + * ``` + * + * @param value The [GeoPoint] value. + * @return A new [Expression] constant instance. + */ + +public static final com.google.firebase.firestore.pipeline.Expression constant(com.google.firebase.firestore.GeoPoint value) { throw new RuntimeException("Stub!"); } + +/** + * Create a constant for a bytes value. + * + * ```kotlin + * // Create a constant with a byte array + * constant(byteArrayOf(0x48, 0x65, 0x6c, 0x6c, 0x6f)) // "Hello" + * ``` + * + * @param value The bytes value. + * @return A new [Expression] constant instance. + */ + +public static final com.google.firebase.firestore.pipeline.Expression constant(byte[] value) { throw new RuntimeException("Stub!"); } + +/** + * Create a constant for a [Blob] value. + * + * ```kotlin + * // Create a constant with a Blob + * constant(Blob.fromBytes(byteArrayOf(0x48, 0x65, 0x6c, 0x6c, 0x6f))) // "Hello" + * ``` + * + * @param value The [Blob] value. + * @return A new [Expression] constant instance. + */ + +public static final com.google.firebase.firestore.pipeline.Expression constant(com.google.firebase.firestore.Blob value) { throw new RuntimeException("Stub!"); } + +/** + * Create a constant for a [DocumentReference] value. + * + * ```kotlin + * // val firestore = FirebaseFirestore.getInstance() + * // val docRef = firestore.collection("cities").document("SF") + * // constant(docRef) + * ``` + * + * @param ref The [DocumentReference] value. + * @return A new [Expression] constant instance. + */ + +public static final com.google.firebase.firestore.pipeline.Expression constant(com.google.firebase.firestore.DocumentReference ref) { throw new RuntimeException("Stub!"); } + +/** + * Create a constant for a [VectorValue] value. + * + * ```kotlin + * // Create a constant with a VectorValue + * constant(VectorValue(listOf(1.0, 2.0, 3.0))) + * ``` + * + * @param value The [VectorValue] value. + * @return A new [Expression] constant instance. + */ + +public static final com.google.firebase.firestore.pipeline.Expression constant(com.google.firebase.firestore.VectorValue value) { throw new RuntimeException("Stub!"); } + +/** + * Constant for a null value. + * + * ```kotlin + * // Create a null constant + * nullValue() + * ``` + * + * @return A [Expression] constant instance. + */ + +public static final com.google.firebase.firestore.pipeline.Expression nullValue() { throw new RuntimeException("Stub!"); } + +/** + * Create a vector constant for a [DoubleArray] value. + * + * ```kotlin + * // Create a vector constant from a DoubleArray + * vector(doubleArrayOf(1.0, 2.0, 3.0)) + * ``` + * + * @param vector The [DoubleArray] value. + * @return A [Expression] constant instance. + */ + +public static final com.google.firebase.firestore.pipeline.Expression vector(double[] vector) { throw new RuntimeException("Stub!"); } + +/** + * Create a vector constant for a [VectorValue] value. + * + * ```kotlin + * // Create a vector constant from a VectorValue + * vector(VectorValue(listOf(1.0, 2.0, 3.0))) + * ``` + * + * @param vector The [VectorValue] value. + * @return A [Expression] constant instance. + */ + +public static final com.google.firebase.firestore.pipeline.Expression vector(com.google.firebase.firestore.VectorValue vector) { throw new RuntimeException("Stub!"); } + +/** + * Creates a [Field] instance representing the field at the given path. + * + * The path can be a simple field name (e.g., "name") or a dot-separated path to a nested field + * (e.g., "address.city"). + * + * @param name The path to the field. + * @return A new [Field] instance representing the specified path. + */ + +public static final com.google.firebase.firestore.pipeline.Field field(java.lang.String name) { throw new RuntimeException("Stub!"); } + +/** + * Creates a [Field] instance representing the field at the given path. + * + * The path can be a simple field name (e.g., "name") or a dot-separated path to a nested field + * (e.g., "address.city"). + * + * ```kotlin + * // Get the 'address.city' field + * field(FieldPath.of("address", "city")) + * ``` + * + * @param fieldPath The [FieldPath] to the field. + * @return A new [Field] instance representing the specified path. + */ + +public static final com.google.firebase.firestore.pipeline.Field field(com.google.firebase.firestore.FieldPath fieldPath) { throw new RuntimeException("Stub!"); } + +/** + * Creates a 'raw' function expression. This is useful if the expression is available in the + * backend, but not yet in the current version of the SDK yet. + * + * ```kotlin + * // Create a generic function call + * rawFunction("my_function", field("arg1"), constant(42)) + * ``` + * + * @param name The name of the raw function. + * @param expr The expressions to be passed as arguments to the function. + * @return A new [Expression] representing the raw function. + */ + +public static final com.google.firebase.firestore.pipeline.Expression rawFunction(java.lang.String name, com.google.firebase.firestore.pipeline.Expression... expr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that performs a logical 'AND' operation. + * + * ```kotlin + * // Check if 'status' is "new" and 'priority' is greater than 1 + * and(field("status").equal("new"), field("priority").greaterThan(1)) + * ``` + * + * @param condition The first [BooleanExpression]. + * @param conditions Additional [BooleanExpression]s. + * @return A new [BooleanExpression] representing the logical 'AND' operation. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression and(com.google.firebase.firestore.pipeline.BooleanExpression condition, com.google.firebase.firestore.pipeline.BooleanExpression... conditions) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that performs a logical 'OR' operation. + * + * ```kotlin + * // Check if 'status' is "new" or "open" + * or(field("status").equal("new"), field("status").equal("open")) + * ``` + * + * @param condition The first [BooleanExpression]. + * @param conditions Additional [BooleanExpression]s. + * @return A new [BooleanExpression] representing the logical 'OR' operation. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression or(com.google.firebase.firestore.pipeline.BooleanExpression condition, com.google.firebase.firestore.pipeline.BooleanExpression... conditions) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that performs a logical 'NOR' operation. + * + * ```kotlin + * // Check if 'status' is neither "new" nor "open" + * nor(field("status").equal("new"), field("status").equal("open")) + * ``` + * + * @param condition The first [BooleanExpression]. + * @param conditions Additional [BooleanExpression]s. + * @return A new [BooleanExpression] representing the logical 'NOR' operation. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression nor(com.google.firebase.firestore.pipeline.BooleanExpression condition, com.google.firebase.firestore.pipeline.BooleanExpression... conditions) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that evaluates to the result corresponding to the first true condition. + * + * This function behaves like a `switch` statement. It accepts an alternating sequence of + * conditions and their corresponding results. If an odd number of arguments is provided, the + * final argument serves as a default fallback result. If no default is provided and no + * condition evaluates to true, it throws an error. + * + * ```kotlin + * // Return "Active" if field "status" is 1, "Pending" if field "status" is 2, + * // and default to "Unknown" if none of the conditions are true. + * switchOn( + * field("status").equal(1), constant("Active"), + * field("status").equal(2), constant("Pending"), + * constant("Unknown") + * ) + * ``` + * + * @param condition The first condition to check. + * @param result The result if the first condition is true. + * @param others Additional conditions and results, and optionally a default value. + * @return A new [Expression] representing the switch operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression switchOn(com.google.firebase.firestore.pipeline.BooleanExpression condition, java.lang.Object result, java.lang.Object... others) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that performs a logical 'XOR' operation. + * + * ```kotlin + * // Check if either 'a' is true or 'b' is true, but not both + * xor(field("a"), field("b")) + * ``` + * + * @param condition The first [BooleanExpression]. + * @param conditions Additional [BooleanExpression]s. + * @return A new [BooleanExpression] representing the logical 'XOR' operation. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression xor(com.google.firebase.firestore.pipeline.BooleanExpression condition, com.google.firebase.firestore.pipeline.BooleanExpression... conditions) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that negates a boolean expression. + * + * ```kotlin + * // Check if 'is_admin' is not true + * not(field("is_admin")) + * ``` + * + * @param condition The boolean expression to negate. + * @return A new [BooleanExpression] representing the not operation. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression not(com.google.firebase.firestore.pipeline.BooleanExpression condition) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise AND operation between two expressions. + * + * ```kotlin + * // Bitwise AND the value of the 'flags' field with the value of the 'mask' field. + * bitAnd(field("flags"), field("mask")) + * ``` + * + * @param bits An expression that returns bits when evaluated. + * @param bitsOther An expression that returns bits when evaluated. + * @return A new [Expression] representing the bitwise AND operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression bitAnd(com.google.firebase.firestore.pipeline.Expression bits, com.google.firebase.firestore.pipeline.Expression bitsOther) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise AND operation between an expression and a + * constant. + * + * ```kotlin + * // Bitwise AND the value of the 'flags' field with a constant mask. + * bitAnd(field("flags"), byteArrayOf(0b00001111)) + * ``` + * + * @param bits An expression that returns bits when evaluated. + * @param bitsOther A constant byte array. + * @return A new [Expression] representing the bitwise AND operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression bitAnd(com.google.firebase.firestore.pipeline.Expression bits, byte[] bitsOther) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise AND operation between an field and an + * expression. + * + * ```kotlin + * // Bitwise AND the value of the 'flags' field with the value of the 'mask' field. + * bitAnd("flags", field("mask")) + * ``` + * + * @param bitsFieldName Name of field that contains bits data. + * @param bitsOther An expression that returns bits when evaluated. + * @return A new [Expression] representing the bitwise AND operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression bitAnd(java.lang.String bitsFieldName, com.google.firebase.firestore.pipeline.Expression bitsOther) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise AND operation between an field and constant. + * + * ```kotlin + * // Bitwise AND the value of the 'flags' field with a constant mask. + * bitAnd("flags", byteArrayOf(0b00001111)) + * ``` + * + * @param bitsFieldName Name of field that contains bits data. + * @param bitsOther A constant byte array. + * @return A new [Expression] representing the bitwise AND operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression bitAnd(java.lang.String bitsFieldName, byte[] bitsOther) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise OR operation between two expressions. + * + * ```kotlin + * // Bitwise OR the value of the 'flags' field with the value of the 'mask' field. + * bitOr(field("flags"), field("mask")) + * ``` + * + * @param bits An expression that returns bits when evaluated. + * @param bitsOther An expression that returns bits when evaluated. + * @return A new [Expression] representing the bitwise OR operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression bitOr(com.google.firebase.firestore.pipeline.Expression bits, com.google.firebase.firestore.pipeline.Expression bitsOther) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise OR operation between an expression and a + * constant. + * + * ```kotlin + * // Bitwise OR the value of the 'flags' field with a constant mask. + * bitOr(field("flags"), byteArrayOf(0b00001111)) + * ``` + * + * @param bits An expression that returns bits when evaluated. + * @param bitsOther A constant byte array. + * @return A new [Expression] representing the bitwise OR operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression bitOr(com.google.firebase.firestore.pipeline.Expression bits, byte[] bitsOther) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise OR operation between an field and an expression. + * + * ```kotlin + * // Bitwise OR the value of the 'flags' field with the value of the 'mask' field. + * bitOr("flags", field("mask")) + * ``` + * + * @param bitsFieldName Name of field that contains bits data. + * @param bitsOther An expression that returns bits when evaluated. + * @return A new [Expression] representing the bitwise OR operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression bitOr(java.lang.String bitsFieldName, com.google.firebase.firestore.pipeline.Expression bitsOther) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise OR operation between an field and constant. + * + * ```kotlin + * // Bitwise OR the value of the 'flags' field with a constant mask. + * bitOr("flags", byteArrayOf(0b00001111)) + * ``` + * + * @param bitsFieldName Name of field that contains bits data. + * @param bitsOther A constant byte array. + * @return A new [Expression] representing the bitwise OR operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression bitOr(java.lang.String bitsFieldName, byte[] bitsOther) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise XOR operation between two expressions. + * + * ```kotlin + * // Bitwise XOR the value of the 'flags' field with the value of the 'mask' field. + * bitXor(field("flags"), field("mask")) + * ``` + * + * @param bits An expression that returns bits when evaluated. + * @param bitsOther An expression that returns bits when evaluated. + * @return A new [Expression] representing the bitwise XOR operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression bitXor(com.google.firebase.firestore.pipeline.Expression bits, com.google.firebase.firestore.pipeline.Expression bitsOther) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise XOR operation between an expression and a + * constant. + * + * ```kotlin + * // Bitwise XOR the value of the 'flags' field with a constant mask. + * bitXor(field("flags"), byteArrayOf(0b00001111)) + * ``` + * + * @param bits An expression that returns bits when evaluated. + * @param bitsOther A constant byte array. + * @return A new [Expression] representing the bitwise XOR operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression bitXor(com.google.firebase.firestore.pipeline.Expression bits, byte[] bitsOther) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise XOR operation between an field and an + * expression. + * + * ```kotlin + * // Bitwise XOR the value of the 'flags' field with the value of the 'mask' field. + * bitXor("flags", field("mask")) + * ``` + * + * @param bitsFieldName Name of field that contains bits data. + * @param bitsOther An expression that returns bits when evaluated. + * @return A new [Expression] representing the bitwise XOR operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression bitXor(java.lang.String bitsFieldName, com.google.firebase.firestore.pipeline.Expression bitsOther) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise XOR operation between an field and constant. + * + * ```kotlin + * // Bitwise XOR the value of the 'flags' field with a constant mask. + * bitXor("flags", byteArrayOf(0b00001111)) + * ``` + * + * @param bitsFieldName Name of field that contains bits data. + * @param bitsOther A constant byte array. + * @return A new [Expression] representing the bitwise XOR operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression bitXor(java.lang.String bitsFieldName, byte[] bitsOther) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise NOT operation to an expression. + * + * ```kotlin + * // Bitwise NOT the value of the 'flags' field. + * bitNot(field("flags")) + * ``` + * + * @param bits An expression that returns bits when evaluated. + * @return A new [Expression] representing the bitwise NOT operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression bitNot(com.google.firebase.firestore.pipeline.Expression bits) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise NOT operation to a field. + * + * ```kotlin + * // Bitwise NOT the value of the 'flags' field. + * bitNot("flags") + * ``` + * + * @param bitsFieldName Name of field that contains bits data. + * @return A new [Expression] representing the bitwise NOT operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression bitNot(java.lang.String bitsFieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise left shift operation between two expressions. + * + * ```kotlin + * // Left shift the value of the 'bits' field by the value of the 'shift' field. + * bitLeftShift(field("bits"), field("shift")) + * ``` + * + * @param bits An expression that returns bits when evaluated. + * @param numberExpr The number of bits to shift. + * @return A new [Expression] representing the bitwise left shift operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression bitLeftShift(com.google.firebase.firestore.pipeline.Expression bits, com.google.firebase.firestore.pipeline.Expression numberExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise left shift operation between an expression and a + * constant. + * + * ```kotlin + * // Left shift the value of the 'bits' field by 2. + * bitLeftShift(field("bits"), 2) + * ``` + * + * @param bits An expression that returns bits when evaluated. + * @param number The number of bits to shift. + * @return A new [Expression] representing the bitwise left shift operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression bitLeftShift(com.google.firebase.firestore.pipeline.Expression bits, int number) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise left shift operation between a field and an + * expression. + * + * ```kotlin + * // Left shift the value of the 'bits' field by the value of the 'shift' field. + * bitLeftShift("bits", field("shift")) + * ``` + * + * @param bitsFieldName Name of field that contains bits data. + * @param numberExpr The number of bits to shift. + * @return A new [Expression] representing the bitwise left shift operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression bitLeftShift(java.lang.String bitsFieldName, com.google.firebase.firestore.pipeline.Expression numberExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise left shift operation between a field and a + * constant. + * + * ```kotlin + * // Left shift the value of the 'bits' field by 2. + * bitLeftShift("bits", 2) + * ``` + * + * @param bitsFieldName Name of field that contains bits data. + * @param number The number of bits to shift. + * @return A new [Expression] representing the bitwise left shift operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression bitLeftShift(java.lang.String bitsFieldName, int number) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise right shift operation between two expressions. + * + * ```kotlin + * // Right shift the value of the 'bits' field by the value of the 'shift' field. + * bitRightShift(field("bits"), field("shift")) + * ``` + * + * @param bits An expression that returns bits when evaluated. + * @param numberExpr The number of bits to shift. + * @return A new [Expression] representing the bitwise right shift operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression bitRightShift(com.google.firebase.firestore.pipeline.Expression bits, com.google.firebase.firestore.pipeline.Expression numberExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise right shift operation between an expression and + * a constant. + * + * ```kotlin + * // Right shift the value of the 'bits' field by 2. + * bitRightShift(field("bits"), 2) + * ``` + * + * @param bits An expression that returns bits when evaluated. + * @param number The number of bits to shift. + * @return A new [Expression] representing the bitwise right shift operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression bitRightShift(com.google.firebase.firestore.pipeline.Expression bits, int number) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise right shift operation between a field and an + * expression. + * + * ```kotlin + * // Right shift the value of the 'bits' field by the value of the 'shift' field. + * bitRightShift("bits", field("shift")) + * ``` + * + * @param bitsFieldName Name of field that contains bits data. + * @param numberExpr The number of bits to shift. + * @return A new [Expression] representing the bitwise right shift operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression bitRightShift(java.lang.String bitsFieldName, com.google.firebase.firestore.pipeline.Expression numberExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise right shift operation between a field and a + * constant. + * + * ```kotlin + * // Right shift the value of the 'bits' field by 2. + * bitRightShift("bits", 2) + * ``` + * + * @param bitsFieldName Name of field that contains bits data. + * @param number The number of bits to shift. + * @return A new [Expression] representing the bitwise right shift operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression bitRightShift(java.lang.String bitsFieldName, int number) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that rounds [numericExpr] to nearest integer. + * + * ```kotlin + * // Round the value of the 'price' field. + * round(field("price")) + * ``` + * + * Rounds away from zero in halfway cases. + * + * @param numericExpr An expression that returns number when evaluated. + * @return A new [Expression] representing an integer result from the round operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression round(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that rounds [numericField] to nearest integer. + * + * ```kotlin + * // Round the value of the 'price' field. + * round("price") + * ``` + * + * Rounds away from zero in halfway cases. + * + * @param numericField Name of field that returns number when evaluated. + * @return A new [Expression] representing an integer result from the round operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression round(java.lang.String numericField) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that rounds off [numericExpr] to [decimalPlace] decimal places if + * [decimalPlace] is positive, rounds off digits to the left of the decimal point if + * [decimalPlace] is negative. Rounds away from zero in halfway cases. + * + * ```kotlin + * // Round the value of the 'price' field to 2 decimal places. + * roundToPrecision(field("price"), 2) + * ``` + * + * @param numericExpr An expression that returns number when evaluated. + * @param decimalPlace The number of decimal places to round. + * @return A new [Expression] representing the round operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression roundToPrecision(com.google.firebase.firestore.pipeline.Expression numericExpr, int decimalPlace) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that rounds off [numericField] to [decimalPlace] decimal places if + * [decimalPlace] is positive, rounds off digits to the left of the decimal point if + * [decimalPlace] is negative. Rounds away from zero in halfway cases. + * + * ```kotlin + * // Round the value of the 'price' field to 2 decimal places. + * roundToPrecision("price", 2) + * ``` + * + * @param numericField Name of field that returns number when evaluated. + * @param decimalPlace The number of decimal places to round. + * @return A new [Expression] representing the round operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression roundToPrecision(java.lang.String numericField, int decimalPlace) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that rounds off [numericExpr] to [decimalPlace] decimal places if + * [decimalPlace] is positive, rounds off digits to the left of the decimal point if + * [decimalPlace] is negative. Rounds away from zero in halfway cases. + * + * ```kotlin + * // Round the value of the 'price' field to the number of decimal places specified in the + * // 'precision' field. + * roundToPrecision(field("price"), field("precision")) + * ``` + * + * @param numericExpr An expression that returns number when evaluated. + * @param decimalPlace The number of decimal places to round. + * @return A new [Expression] representing the round operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression roundToPrecision(com.google.firebase.firestore.pipeline.Expression numericExpr, com.google.firebase.firestore.pipeline.Expression decimalPlace) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that rounds off [numericField] to [decimalPlace] decimal places if + * [decimalPlace] is positive, rounds off digits to the left of the decimal point if + * [decimalPlace] is negative. Rounds away from zero in halfway cases. + * + * ```kotlin + * // Round the value of the 'price' field to the number of decimal places specified in the + * // 'precision' field. + * roundToPrecision("price", field("precision")) + * ``` + * + * @param numericField Name of field that returns number when evaluated. + * @param decimalPlace The number of decimal places to round. + * @return A new [Expression] representing the round operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression roundToPrecision(java.lang.String numericField, com.google.firebase.firestore.pipeline.Expression decimalPlace) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates [numericExpr] to an integer. + * + * ```kotlin + * // Truncate the value of the 'rating' field. + * trunc(field("rating")) + * ``` + * + * @param numericExpr An expression that returns number when evaluated. + * @return A new [Expression] representing the truncate operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression trunc(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates [numericField] to an integer. + * + * ```kotlin + * // Truncate the value of the 'rating' field. + * trunc("rating") + * ``` + * + * @param numericField Name of field that returns number when evaluated. + * @return A new [Expression] representing the truncate operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression trunc(java.lang.String numericField) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates [numericExpr] to [decimalPlace] decimal places if + * [decimalPlace] is positive, truncates digits to the left of the decimal point if + * [decimalPlace] is negative. + * + * ```kotlin + * // Truncate the value of the 'rating' field to 2 decimal places. + * truncToPrecision(field("rating"), 2) + * ``` + * + * @param numericExpr An expression that returns number when evaluated. + * @param decimalPlace The number of decimal places to truncate. + * @return A new [Expression] representing the truncate operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression truncToPrecision(com.google.firebase.firestore.pipeline.Expression numericExpr, int decimalPlace) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates [numericField] to [decimalPlace] decimal places if + * [decimalPlace] is positive, truncates digits to the left of the decimal point if + * [decimalPlace] is negative. + * + * ```kotlin + * // Truncate the value of the 'rating' field to 2 decimal places. + * truncToPrecision("rating", 2) + * ``` + * + * @param numericField Name of field that returns number when evaluated. + * @param decimalPlace The number of decimal places to truncate. + * @return A new [Expression] representing the truncate operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression truncToPrecision(java.lang.String numericField, int decimalPlace) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates [numericExpr] to [decimalPlace] decimal places if + * [decimalPlace] is positive, truncates digits to the left of the decimal point if + * [decimalPlace] is negative. + * + * ```kotlin + * // Truncate the value of the 'rating' field to the number of decimal places specified in the + * // 'precision' field. + * truncToPrecision(field("rating"), field("precision")) + * ``` + * + * @param numericExpr An expression that returns number when evaluated. + * @param decimalPlace The number of decimal places to truncate. + * @return A new [Expression] representing the truncate operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression truncToPrecision(com.google.firebase.firestore.pipeline.Expression numericExpr, com.google.firebase.firestore.pipeline.Expression decimalPlace) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates [numericField] to [decimalPlace] decimal places if + * [decimalPlace] is positive, truncates digits to the left of the decimal point if + * [decimalPlace] is negative. + * + * ```kotlin + * // Truncate the value of the 'rating' field to the number of decimal places specified in the + * // 'precision' field. + * truncToPrecision("rating", field("precision")) + * ``` + * + * @param numericField Name of field that returns number when evaluated. + * @param decimalPlace The number of decimal places to truncate. + * @return A new [Expression] representing the truncate operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression truncToPrecision(java.lang.String numericField, com.google.firebase.firestore.pipeline.Expression decimalPlace) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the smallest integer that isn't less than [numericExpr]. + * + * ```kotlin + * // Compute the ceiling of the 'price' field. + * ceil(field("price")) + * ``` + * + * @param numericExpr An expression that returns number when evaluated. + * @return A new [Expression] representing an integer result from the ceil operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression ceil(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the smallest integer that isn't less than [numericField]. + * + * ```kotlin + * // Compute the ceiling of the 'price' field. + * ceil("price") + * ``` + * + * @param numericField Name of field that returns number when evaluated. + * @return A new [Expression] representing an integer result from the ceil operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression ceil(java.lang.String numericField) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the largest integer that is not greater than [numericExpr] + * + * ```kotlin + * // Compute the floor of the 'price' field. + * floor(field("price")) + * ``` + * + * @param numericExpr An expression that returns number when evaluated. + * @return A new [Expression] representing an integer result from the floor operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression floor(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the largest integer that is not greater than + * [numericField]. + * + * ```kotlin + * // Compute the floor of the 'price' field. + * floor("price") + * ``` + * + * @param numericField Name of field that returns number when evaluated. + * @return A new [Expression] representing an integer result from the floor operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression floor(java.lang.String numericField) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [numericExpr] raised to the power of the [exponent]. + * Returns infinity on overflow and zero on underflow. + * + * ```kotlin + * // Raise the value of the 'base' field to the power of 2. + * pow(field("base"), 2) + * ``` + * + * @param numericExpr An expression that returns number when evaluated. + * @param exponent The numeric power to raise the [numericExpr]. + * @return A new [Expression] representing a numeric result from raising [numericExpr] to the + * power of [exponent]. + */ + +public static final com.google.firebase.firestore.pipeline.Expression pow(com.google.firebase.firestore.pipeline.Expression numericExpr, java.lang.Number exponent) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [numericField] raised to the power of the [exponent]. + * Returns infinity on overflow and zero on underflow. + * + * ```kotlin + * // Raise the value of the 'base' field to the power of 2. + * pow("base", 2) + * ``` + * + * @param numericField Name of field that returns number when evaluated. + * @param exponent The numeric power to raise the [numericField]. + * @return A new [Expression] representing a numeric result from raising [numericField] to the + * power of [exponent]. + */ + +public static final com.google.firebase.firestore.pipeline.Expression pow(java.lang.String numericField, java.lang.Number exponent) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [numericExpr] raised to the power of the [exponent]. + * Returns infinity on overflow and zero on underflow. + * + * ```kotlin + * // Raise the value of the 'base' field to the power of the 'exponent' field. + * pow(field("base"), field("exponent")) + * ``` + * + * @param numericExpr An expression that returns number when evaluated. + * @param exponent The numeric power to raise the [numericExpr]. + * @return A new [Expression] representing a numeric result from raising [numericExpr] to the + * power of [exponent]. + */ + +public static final com.google.firebase.firestore.pipeline.Expression pow(com.google.firebase.firestore.pipeline.Expression numericExpr, com.google.firebase.firestore.pipeline.Expression exponent) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [numericField] raised to the power of the [exponent]. + * Returns infinity on overflow and zero on underflow. + * + * ```kotlin + * // Raise the value of the 'base' field to the power of the 'exponent' field. + * pow("base", field("exponent")) + * ``` + * + * @param numericField Name of field that returns number when evaluated. + * @param exponent The numeric power to raise the [numericField]. + * @return A new [Expression] representing a numeric result from raising [numericField] to the + * power of [exponent]. + */ + +public static final com.google.firebase.firestore.pipeline.Expression pow(java.lang.String numericField, com.google.firebase.firestore.pipeline.Expression exponent) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the absolute value of [numericExpr]. + * + * ```kotlin + * // Get the absolute value of the 'change' field. + * abs(field("change")) + * ``` + * + * @param numericExpr An expression that returns number when evaluated. + * @return A new [Expression] representing the numeric result of the absolute value operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression abs(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the absolute value of [numericField]. + * + * ```kotlin + * // Get the absolute value of the 'change' field. + * abs("change") + * ``` + * + * @param numericField Name of field that returns number when evaluated. + * @return A new [Expression] representing the numeric result of the absolute value operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression abs(java.lang.String numericField) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns Euler's number e raised to the power of [numericExpr]. + * + * ```kotlin + * // Compute e to the power of the 'value' field. + * exp(field("value")) + * ``` + * + * @param numericExpr An expression that returns number when evaluated. + * @return A new [Expression] representing the numeric result of the exponentiation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression exp(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns Euler's number e raised to the power of [numericField]. + * + * ```kotlin + * // Compute e to the power of the 'value' field. + * exp("value") + * ``` + * + * @param numericField Name of field that returns number when evaluated. + * @return A new [Expression] representing the numeric result of the exponentiation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression exp(java.lang.String numericField) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the natural logarithm (base e) of [numericExpr]. + * + * ```kotlin + * // Compute the natural logarithm of the 'value' field. + * ln(field("value")) + * ``` + * + * @param numericExpr An expression that returns number when evaluated. + * @return A new [Expression] representing the numeric result of the natural logarithm. + */ + +public static final com.google.firebase.firestore.pipeline.Expression ln(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the natural logarithm (base e) of [numericField]. + * + * ```kotlin + * // Compute the natural logarithm of the 'value' field. + * ln("value") + * ``` + * + * @param numericField Name of field that returns number when evaluated. + * @return A new [Expression] representing the numeric result of the natural logarithm. + */ + +public static final com.google.firebase.firestore.pipeline.Expression ln(java.lang.String numericField) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the logarithm of [numericExpr] with a given [base]. + * + * ```kotlin + * // Compute the logarithm of the 'value' field with base 10. + * log(field("value"), 10) + * ``` + * + * @param numericExpr An expression that returns number when evaluated. + * @param base The base of the logarithm. + * @return A new [Expression] representing a numeric result from the logarithm of [numericExpr] + * with a given [base]. + */ + +public static final com.google.firebase.firestore.pipeline.Expression log(com.google.firebase.firestore.pipeline.Expression numericExpr, java.lang.Number base) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the logarithm of [numericField] with a given [base]. + * + * ```kotlin + * // Compute the logarithm of the 'value' field with base 10. + * log("value", 10) + * ``` + * + * @param numericField Name of field that returns number when evaluated. + * @param base The base of the logarithm. + * @return A new [Expression] representing a numeric result from the logarithm of [numericField] + * with a given [base]. + */ + +public static final com.google.firebase.firestore.pipeline.Expression log(java.lang.String numericField, java.lang.Number base) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the logarithm of [numericExpr] with a given [base]. + * + * ```kotlin + * // Compute the logarithm of the 'value' field with the base in the 'base' field. + * log(field("value"), field("base")) + * ``` + * + * @param numericExpr An expression that returns number when evaluated. + * @param base The base of the logarithm. + * @return A new [Expression] representing a numeric result from the logarithm of [numericExpr] + * with a given [base]. + */ + +public static final com.google.firebase.firestore.pipeline.Expression log(com.google.firebase.firestore.pipeline.Expression numericExpr, com.google.firebase.firestore.pipeline.Expression base) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the logarithm of [numericField] with a given [base]. + * + * ```kotlin + * // Compute the logarithm of the 'value' field with the base in the 'base' field. + * log("value", field("base")) + * ``` + * + * @param numericField Name of field that returns number when evaluated. + * @param base The base of the logarithm. + * @return A new [Expression] representing a numeric result from the logarithm of [numericField] + * with a given [base]. + */ + +public static final com.google.firebase.firestore.pipeline.Expression log(java.lang.String numericField, com.google.firebase.firestore.pipeline.Expression base) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the base 10 logarithm of [numericExpr]. + * + * ```kotlin + * // Compute the base 10 logarithm of the 'value' field. + * log10(field("value")) + * ``` + * + * @param numericExpr An expression that returns number when evaluated. + * @return A new [Expression] representing the numeric result of the base 10 logarithm. + */ + +public static final com.google.firebase.firestore.pipeline.Expression log10(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the base 10 logarithm of [numericField]. + * + * ```kotlin + * // Compute the base 10 logarithm of the 'value' field. + * log10("value") + * ``` + * + * @param numericField Name of field that returns number when evaluated. + * @return A new [Expression] representing the numeric result of the base 10 logarithm. + */ + +public static final com.google.firebase.firestore.pipeline.Expression log10(java.lang.String numericField) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the square root of [numericExpr]. + * + * ```kotlin + * // Compute the square root of the 'value' field. + * sqrt(field("value")) + * ``` + * + * @param numericExpr An expression that returns number when evaluated. + * @return A new [Expression] representing the numeric result of the square root operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression sqrt(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the square root of [numericField]. + * + * ```kotlin + * // Compute the square root of the 'value' field. + * sqrt("value") + * ``` + * + * @param numericField Name of field that returns number when evaluated. + * @return A new [Expression] representing the numeric result of the square root operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression sqrt(java.lang.String numericField) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that adds numeric expressions. + * + * ```kotlin + * // Add the value of the 'quantity' field and the 'reserve' field. + * add(field("quantity"), field("reserve")) + * ``` + * + * @param first Numeric expression to add. + * @param second Numeric expression to add. + * @return A new [Expression] representing the addition operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression add(com.google.firebase.firestore.pipeline.Expression first, com.google.firebase.firestore.pipeline.Expression second) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that adds numeric expressions with a constant. + * + * ```kotlin + * // Add 5 to the value of the 'quantity' field. + * add(field("quantity"), 5) + * ``` + * + * @param first Numeric expression to add. + * @param second Constant to add. + * @return A new [Expression] representing the addition operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression add(com.google.firebase.firestore.pipeline.Expression first, java.lang.Number second) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that adds a numeric field with a numeric expression. + * + * ```kotlin + * // Add the value of the 'quantity' field and the 'reserve' field. + * add("quantity", field("reserve")) + * ``` + * + * @param numericFieldName Numeric field to add. + * @param second Numeric expression to add to field value. + * @return A new [Expression] representing the addition operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression add(java.lang.String numericFieldName, com.google.firebase.firestore.pipeline.Expression second) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that adds a numeric field with constant. + * + * ```kotlin + * // Add 5 to the value of the 'quantity' field. + * add("quantity", 5) + * ``` + * + * @param numericFieldName Numeric field to add. + * @param second Constant to add. + * @return A new [Expression] representing the addition operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression add(java.lang.String numericFieldName, java.lang.Number second) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that subtracts two expressions. + * + * ```kotlin + * // Subtract the 'discount' field from the 'price' field + * subtract(field("price"), field("discount")) + * ``` + * + * @param minuend Numeric expression to subtract from. + * @param subtrahend Numeric expression to subtract. + * @return A new [Expression] representing the subtract operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression subtract(com.google.firebase.firestore.pipeline.Expression minuend, com.google.firebase.firestore.pipeline.Expression subtrahend) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that subtracts a constant value from a numeric expression. + * + * ```kotlin + * // Subtract 10 from the 'price' field. + * subtract(field("price"), 10) + * ``` + * + * @param minuend Numeric expression to subtract from. + * @param subtrahend Constant to subtract. + * @return A new [Expression] representing the subtract operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression subtract(com.google.firebase.firestore.pipeline.Expression minuend, java.lang.Number subtrahend) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that subtracts a numeric expressions from numeric field. + * + * ```kotlin + * // Subtract the 'discount' field from the 'price' field. + * subtract("price", field("discount")) + * ``` + * + * @param numericFieldName Numeric field to subtract from. + * @param subtrahend Numeric expression to subtract. + * @return A new [Expression] representing the subtract operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression subtract(java.lang.String numericFieldName, com.google.firebase.firestore.pipeline.Expression subtrahend) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that subtracts a constant from numeric field. + * + * ```kotlin + * // Subtract 10 from the 'price' field. + * subtract("price", 10) + * ``` + * + * @param numericFieldName Numeric field to subtract from. + * @param subtrahend Constant to subtract. + * @return A new [Expression] representing the subtract operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression subtract(java.lang.String numericFieldName, java.lang.Number subtrahend) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that multiplies numeric expressions. + * + * ```kotlin + * // Multiply the 'quantity' field by the 'price' field + * multiply(field("quantity"), field("price")) + * ``` + * + * @param first Numeric expression to multiply. + * @param second Numeric expression to multiply. + * @return A new [Expression] representing the multiplication operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression multiply(com.google.firebase.firestore.pipeline.Expression first, com.google.firebase.firestore.pipeline.Expression second) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that multiplies numeric expressions with a constant. + * + * ```kotlin + * // Multiply the 'quantity' field by 1.1. + * multiply(field("quantity"), 1.1) + * ``` + * + * @param first Numeric expression to multiply. + * @param second Constant to multiply. + * @return A new [Expression] representing the multiplication operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression multiply(com.google.firebase.firestore.pipeline.Expression first, java.lang.Number second) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that multiplies a numeric field with a numeric expression. + * + * ```kotlin + * // Multiply the 'quantity' field by the 'price' field. + * multiply("quantity", field("price")) + * ``` + * + * @param numericFieldName Numeric field to multiply. + * @param second Numeric expression to multiply. + * @return A new [Expression] representing the multiplication operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression multiply(java.lang.String numericFieldName, com.google.firebase.firestore.pipeline.Expression second) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that multiplies a numeric field with a constant. + * + * ```kotlin + * // Multiply the 'quantity' field by 1.1. + * multiply("quantity", 1.1) + * ``` + * + * @param numericFieldName Numeric field to multiply. + * @param second Constant to multiply. + * @return A new [Expression] representing the multiplication operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression multiply(java.lang.String numericFieldName, java.lang.Number second) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that divides two numeric expressions. + * + * ```kotlin + * // Divide the 'total' field by the 'count' field + * divide(field("total"), field("count")) + * ``` + * + * @param dividend The numeric expression to be divided. + * @param divisor The numeric expression to divide by. + * @return A new [Expression] representing the division operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression divide(com.google.firebase.firestore.pipeline.Expression dividend, com.google.firebase.firestore.pipeline.Expression divisor) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that divides a numeric expression by a constant. + * + * ```kotlin + * // Divide the 'value' field by 10 + * divide(field("value"), 10) + * ``` + * + * @param dividend The numeric expression to be divided. + * @param divisor The constant to divide by. + * @return A new [Expression] representing the division operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression divide(com.google.firebase.firestore.pipeline.Expression dividend, java.lang.Number divisor) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that divides numeric field by a numeric expression. + * + * ```kotlin + * // Divide the 'total' field by the 'count' field. + * divide("total", field("count")) + * ``` + * + * @param dividendFieldName The numeric field name to be divided. + * @param divisor The numeric expression to divide by. + * @return A new [Expression] representing the divide operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression divide(java.lang.String dividendFieldName, com.google.firebase.firestore.pipeline.Expression divisor) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that divides a numeric field by a constant. + * + * ```kotlin + * // Divide the 'total' field by 2. + * divide("total", 2) + * ``` + * + * @param dividendFieldName The numeric field name to be divided. + * @param divisor The constant to divide by. + * @return A new [Expression] representing the divide operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression divide(java.lang.String dividendFieldName, java.lang.Number divisor) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the modulo (remainder) of dividing two numeric + * expressions. + * + * ```kotlin + * // Calculate the remainder of dividing the 'value' field by the 'divisor' field + * mod(field("value"), field("divisor")) + * ``` + * + * @param dividend The numeric expression to be divided. + * @param divisor The numeric expression to divide by. + * @return A new [Expression] representing the modulo operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression mod(com.google.firebase.firestore.pipeline.Expression dividend, com.google.firebase.firestore.pipeline.Expression divisor) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the modulo (remainder) of dividing a numeric expression + * by a constant. + * + * ```kotlin + * // Calculate the remainder of dividing the 'value' field by 3. + * mod(field("value"), 3) + * ``` + * + * @param dividend The numeric expression to be divided. + * @param divisor The constant to divide by. + * @return A new [Expression] representing the modulo operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression mod(com.google.firebase.firestore.pipeline.Expression dividend, java.lang.Number divisor) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the modulo (remainder) of dividing a numeric field by a + * constant. + * + * ```kotlin + * // Calculate the remainder of dividing the 'value' field by the 'divisor' field. + * mod("value", field("divisor")) + * ``` + * + * @param dividendFieldName The numeric field name to be divided. + * @param divisor The numeric expression to divide by. + * @return A new [Expression] representing the modulo operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression mod(java.lang.String dividendFieldName, com.google.firebase.firestore.pipeline.Expression divisor) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the modulo (remainder) of dividing a numeric field by a + * constant. + * + * ```kotlin + * // Calculate the remainder of dividing the 'value' field by 3. + * mod("value", 3) + * ``` + * + * @param dividendFieldName The numeric field name to be divided. + * @param divisor The constant to divide by. + * @return A new [Expression] representing the modulo operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression mod(java.lang.String dividendFieldName, java.lang.Number divisor) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if an [expression], when evaluated, is equal to any of the + * provided [values]. + * + * ```kotlin + * // Check if the 'category' field is either "Electronics" or the value of the 'primaryType' field. + * equalAny(field("category"), listOf("Electronics", field("primaryType"))) + * ``` + * + * @param expression The expression whose results to compare. + * @param values The values to check against. + * @return A new [BooleanExpression] representing the 'IN' comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression equalAny(com.google.firebase.firestore.pipeline.Expression expression, java.util.List values) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if an [expression], when evaluated, is equal to any of the + * elements of [arrayExpression]. + * + * ```kotlin + * // Check if the 'category' field is in the 'availableCategories' array field. + * equalAny(field("category"), field("availableCategories")) + * ``` + * + * @param expression The expression whose results to compare. + * @param arrayExpression An expression that evaluates to an array, whose elements to check for + * equality to the input. + * @return A new [BooleanExpression] representing the 'IN' comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression equalAny(com.google.firebase.firestore.pipeline.Expression expression, com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field's value is equal to any of the provided [values] + * . + * + * ```kotlin + * // Check if the 'category' field is either "Electronics" or "Apparel". + * equalAny("category", listOf("Electronics", "Apparel")) + * ``` + * + * @param fieldName The field to compare. + * @param values The values to check against. + * @return A new [BooleanExpression] representing the 'IN' comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression equalAny(java.lang.String fieldName, java.util.List values) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field's value is equal to any of the elements of + * [arrayExpression]. + * + * ```kotlin + * // Check if the 'category' field is in the 'availableCategories' array field. + * equalAny("category", field("availableCategories")) + * ``` + * + * @param fieldName The field to compare. + * @param arrayExpression An expression that evaluates to an array, whose elements to check for + * equality to the input. + * @return A new [BooleanExpression] representing the 'IN' comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression equalAny(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if an [expression], when evaluated, is not equal to all the + * provided [values]. + * + * ```kotlin + * // Check if the 'status' field is neither "pending" nor the value of the 'rejectedStatus' field. + * notEqualAny(field("status"), listOf("pending", field("rejectedStatus"))) + * ``` + * + * @param expression The expression whose results to compare. + * @param values The values to check against. + * @return A new [BooleanExpression] representing the 'NOT IN' comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression notEqualAny(com.google.firebase.firestore.pipeline.Expression expression, java.util.List values) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if an [expression], when evaluated, is not equal to all the + * elements of [arrayExpression]. + * + * ```kotlin + * // Check if the 'status' field is not in the 'inactiveStatuses' array field. + * notEqualAny(field("status"), field("inactiveStatuses")) + * ``` + * + * @param expression The expression whose results to compare. + * @param arrayExpression An expression that evaluates to an array, whose elements to check for + * equality to the input. + * @return A new [BooleanExpression] representing the 'NOT IN' comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression notEqualAny(com.google.firebase.firestore.pipeline.Expression expression, com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field's value is not equal to all of the provided + * [values]. + * + * ```kotlin + * // Check if the 'status' field is not "archived" or "deleted". + * notEqualAny("status", listOf("archived", "deleted")) + * ``` + * + * @param fieldName The field to compare. + * @param values The values to check against. + * @return A new [BooleanExpression] representing the 'NOT IN' comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression notEqualAny(java.lang.String fieldName, java.util.List values) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field's value is not equal to all of the elements of + * [arrayExpression]. + * + * ```kotlin + * // Check if the 'status' field is not in the 'inactiveStatuses' array field. + * notEqualAny("status", field("inactiveStatuses")) + * ``` + * + * @param fieldName The field to compare. + * @param arrayExpression An expression that evaluates to an array, whose elements to check for + * equality to the input. + * @return A new [BooleanExpression] representing the 'NOT IN' comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression notEqualAny(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns true if a value is absent. Otherwise, returns false even + * if the value is null. + * + * ```kotlin + * // Check if the field `value` is absent. + * isAbsent(field("value")) + * ``` + * + * @param value The expression to check. + * @return A new [BooleanExpression] representing the isAbsent operation. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression isAbsent(com.google.firebase.firestore.pipeline.Expression value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns true if a field is absent. Otherwise, returns false even + * if the field value is null. + * + * ```kotlin + * // Check if the field `value` is absent. + * isAbsent("value") + * ``` + * + * @param fieldName The field to check. + * @return A new [BooleanExpression] representing the isAbsent operation. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression isAbsent(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a string indicating the type of the value this expression + * evaluates to. + * + * ```kotlin + * // Get the type of the 'value' field. + * type(field("value")) + * ``` + * + * @param expr The expression to get the type of. + * @return A new [Expression] representing the type operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression type(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a string indicating the type of the value this field + * evaluates to. + * + * ```kotlin + * // Get the type of the 'field' field. + * type("field") + * ``` + * + * @param fieldName The name of the field to get the type of. + * @return A new [Expression] representing the type operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression type(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if the result of an expression is of the given type. + * + * Supported values for `type` are: "null", "array", "boolean", "bytes", "timestamp", + * "geo_point", "number", "int32", "int64", "float64", "decimal128", "map", "reference", + * "string", "vector", "max_key", "min_key", "object_id", "regex", and "request_timestamp". + * + * ```kotlin + * // Check if the 'age' field is an integer + * isType(field("age"), "int64") + * ``` + * + * @param expr The expression to check the type of. + * @param type The type to check for. + * @return A new [BooleanExpression] that evaluates to true if the expression's result is of the + * given type, false otherwise. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression isType(com.google.firebase.firestore.pipeline.Expression expr, java.lang.String type) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if the value of a field is of the given type. + * + * Supported values for `type` are: "null", "array", "boolean", "bytes", "timestamp", + * "geo_point", "number", "int32", "int64", "float64", "decimal128", "map", "reference", + * "string", "vector", "max_key", "min_key", "object_id", "regex", and "request_timestamp". + * + * ```kotlin + * // Check if the 'age' field is an integer + * isType("age", "int64") + * ``` + * + * @param fieldName The name of the field to check the type of. + * @param type The type to check for. + * @return A new [BooleanExpression] that evaluates to true if the expression's result is of the + * given type, false otherwise. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression isType(java.lang.String fieldName, java.lang.String type) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the length of a string, array, map, vector, or blob + * expression. + * + * ```kotlin + * // Get the length of the 'value' field where the value type can be any of a string, array, map, vector or blob. + * length(field("value")) + * ``` + * + * @param expr The expression representing the string. + * @return A new [Expression] representing the length operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression length(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the length of a string, array, map, vector, or blob + * field. + * + * ```kotlin + * // Get the length of the 'value' field where the value type can be any of a string, array, map, vector or blob. + * charLength("value") + * ``` + * + * @param fieldName The name of the field containing the string. + * @return A new [Expression] representing the length operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression length(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the character length of a string expression in UTF8. + * + * ```kotlin + * // Get the character length of the 'name' field in UTF-8. + * charLength("name") + * ``` + * + * @param expr The expression representing the string. + * @return A new [Expression] representing the charLength operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression charLength(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the character length of a string field in UTF8. + * + * ```kotlin + * // Get the character length of the 'name' field in UTF-8. + * charLength("name") + * ``` + * + * @param fieldName The name of the field containing the string. + * @return A new [Expression] representing the charLength operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression charLength(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the length of a string in UTF-8 bytes, or just the + * length of a Blob. + * + * ```kotlin + * // Calculate the length of the 'myString' field in bytes. + * byteLength("myString") + * ``` + * + * @param value The expression representing the string. + * @return A new [Expression] representing the length of the string in bytes. + */ + +public static final com.google.firebase.firestore.pipeline.Expression byteLength(com.google.firebase.firestore.pipeline.Expression value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the length of a string represented by a field in UTF-8 + * bytes, or just the length of a Blob. + * + * ```kotlin + * // Calculate the length of the 'myString' field in bytes. + * byteLength("myString") + * ``` + * + * @param fieldName The name of the field containing the string. + * @return A new [Expression] representing the length of the string in bytes. + */ + +public static final com.google.firebase.firestore.pipeline.Expression byteLength(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that performs a case-sensitive wildcard string comparison. + * + * ```kotlin + * // Check if the 'title' field contains the string "guide" + * like(field("title"), "%guide%") + * ``` + * + * @param stringExpression The expression representing the string to perform the comparison on. + * @param pattern The pattern to search for. You can use "%" as a wildcard character. + * @return A new [BooleanExpression] representing the like operation. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression like(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that splits a string or blob by a delimiter. + * + * ```kotlin + * // Split the 'tags' field by a comma + * split(field("tags"), field("delimiter")) + * ``` + * + * @param value The expression evaluating to a string or blob to be split. + * @param delimiter The delimiter to split by. Must be of the same type as `value`. + * @return A new [Expression] that evaluates to an array of segments. + */ + +public static final com.google.firebase.firestore.pipeline.Expression split(com.google.firebase.firestore.pipeline.Expression value, com.google.firebase.firestore.pipeline.Expression delimiter) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that splits a string or blob by a string delimiter. + * + * ```kotlin + * // Split the 'tags' field by a comma + * split(field("tags"), ",") + * ``` + * + * @param value The expression evaluating to a string or blob to be split. + * @param delimiter The string delimiter to split by. + * @return A new [Expression] that evaluates to an array of segments. + */ + +public static final com.google.firebase.firestore.pipeline.Expression split(com.google.firebase.firestore.pipeline.Expression value, java.lang.String delimiter) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that splits a blob by a blob delimiter. + * + * ```kotlin + * // Split the 'data' field by a delimiter + * split(field("data"), Blob.fromBytes(byteArrayOf(0x0a))) + * ``` + * + * @param value The expression evaluating to a blob to be split. + * @param delimiter The blob delimiter to split by. + * @return A new [Expression] that evaluates to an array of segments. + */ + +public static final com.google.firebase.firestore.pipeline.Expression split(com.google.firebase.firestore.pipeline.Expression value, com.google.firebase.firestore.Blob delimiter) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that splits a string or blob field by a delimiter. + * + * ```kotlin + * // Split the 'tags' field by the value of the 'delimiter' field + * split("tags", field("delimiter")) + * ``` + * + * @param fieldName The name of the field containing the string or blob to be split. + * @param delimiter The delimiter to split by. + * @return A new [Expression] that evaluates to an array of segments. + */ + +public static final com.google.firebase.firestore.pipeline.Expression split(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression delimiter) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that splits a string or blob field by a string delimiter. + * + * ```kotlin + * // Split the 'tags' field by a comma + * split("tags", ",") + * ``` + * + * @param fieldName The name of the field containing the string or blob to be split. + * @param delimiter The string delimiter to split by. + * @return A new [Expression] that evaluates to an array of segments. + */ + +public static final com.google.firebase.firestore.pipeline.Expression split(java.lang.String fieldName, java.lang.String delimiter) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that splits a blob field by a blob delimiter. + * + * ```kotlin + * // Split the 'data' field by a delimiter + * split("data", Blob.fromBytes(byteArrayOf(0x0a))) + * ``` + * + * @param fieldName The name of the field containing the blob to be split. + * @param delimiter The blob delimiter to split by. + * @return A new [Expression] that evaluates to an array of segments. + */ + +public static final com.google.firebase.firestore.pipeline.Expression split(java.lang.String fieldName, com.google.firebase.firestore.Blob delimiter) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that joins the elements of an array into a string. + * + * ```kotlin + * // Join the elements of the 'tags' field with a comma and space. + * join(field("tags"), ", ") + * ``` + * + * @param arrayExpression The expression that evaluates to an array. + * @param delimiter The string to use as a delimiter. + * @return A new [Expression] representing the join operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression join(com.google.firebase.firestore.pipeline.Expression arrayExpression, java.lang.String delimiter) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that joins the elements of an array into a string. + * + * ```kotlin + * // Join the elements of the 'tags' field with the delimiter from the 'separator' field. + * join(field("tags"), field("separator")) + * ``` + * + * @param arrayExpression The expression that evaluates to an array. + * @param delimiterExpression The expression that evaluates to the delimiter string. + * @return A new [Expression] representing the join operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression join(com.google.firebase.firestore.pipeline.Expression arrayExpression, com.google.firebase.firestore.pipeline.Expression delimiterExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that joins the elements of an array field into a string. + * + * ```kotlin + * // Join the elements of the 'tags' field with a comma and space. + * join("tags", ", ") + * ``` + * + * @param arrayFieldName The name of the field containing the array. + * @param delimiter The string to use as a delimiter. + * @return A new [Expression] representing the join operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression join(java.lang.String arrayFieldName, java.lang.String delimiter) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that joins the elements of an array field into a string. + * + * ```kotlin + * // Join the elements of the 'tags' field with the delimiter from the 'separator' field. + * join("tags", field("separator")) + * ``` + * + * @param arrayFieldName The name of the field containing the array. + * @param delimiterExpression The expression that evaluates to the delimiter string. + * @return A new [Expression] representing the join operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression join(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression delimiterExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that performs a case-sensitive wildcard string comparison. + * + * ```kotlin + * // Check if the 'title' field contains the string "guide" + * like(field("title"), "%guide%") + * ``` + * + * @param stringExpression The expression representing the string to perform the comparison on. + * @param pattern The pattern to search for. You can use "%" as a wildcard character. + * @return A new [BooleanExpression] representing the like operation. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression like(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that performs a case-sensitive wildcard string comparison against a + * field. + * + * ```kotlin + * // Check if the 'title' field contains the string "guide" + * like("title", "%guide%") + * ``` + * + * @param fieldName The name of the field containing the string. + * @param pattern The pattern to search for. You can use "%" as a wildcard character. + * @return A new [BooleanExpression] representing the like comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression like(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that performs a case-sensitive wildcard string comparison against a + * field. + * + * ```kotlin + * // Check if the 'title' field contains the string "guide" + * like("title", "%guide%") + * ``` + * + * @param fieldName The name of the field containing the string. + * @param pattern The pattern to search for. You can use "%" as a wildcard character. + * @return A new [BooleanExpression] representing the like comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression like(java.lang.String fieldName, java.lang.String pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a pseudo-random number of type double in the range of [0, + * 1), inclusive of 0 and exclusive of 1. + * + * ```kotlin + * // Get a random number. + * rand() + * ``` + * + * @return A new [Expression] representing the random number operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression rand() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string expression contains a specified regular + * expression as a substring. + * + * ```kotlin + * // Check if the 'description' field contains "example" (case-insensitive) + * regexContains(field("description"), "(?i)example") + * ``` + * + * @param stringExpression The expression representing the string to perform the comparison on. + * @param pattern The regular expression to use for the search. + * @return A new [BooleanExpression] representing the contains regular expression comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression regexContains(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string expression contains a specified regular + * expression as a substring. + * + * ```kotlin + * // Check if the 'description' field contains "example" (case-insensitive) + * regexContains(field("description"), "(?i)example") + * ``` + * + * @param stringExpression The expression representing the string to perform the comparison on. + * @param pattern The regular expression to use for the search. + * @return A new [BooleanExpression] representing the contains regular expression comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression regexContains(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string field contains a specified regular expression + * as a substring. + * + * ```kotlin + * // Check if the 'description' field contains the regex from the 'pattern' field. + * regexContains("description", field("pattern")) + * ``` + * + * @param fieldName The name of the field containing the string. + * @param pattern The regular expression to use for the search. + * @return A new [BooleanExpression] representing the contains regular expression comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression regexContains(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string field contains a specified regular expression + * as a substring. + * + * ```kotlin + * // Check if the 'description' field contains "example" (case-insensitive) + * regexContains("description", "(?i)example") + * ``` + * + * @param fieldName The name of the field containing the string. + * @param pattern The regular expression to use for the search. + * @return A new [BooleanExpression] representing the contains regular expression comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression regexContains(java.lang.String fieldName, java.lang.String pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first substring of a string expression that matches a + * specified regular expression. + * + * This expression uses the [RE2](https://github.com/google/re2/wiki/Syntax) regular expression + * syntax. + * + * ```kotlin + * // Extract a substring based on a dynamic pattern field + * regexFind(field("email"), field("pattern")) + * ``` + * + * @param stringExpression The expression representing the string to search. + * @param pattern The regular expression to search for. + * @return A new [Expression] representing the regular expression find function. + */ + +public static final com.google.firebase.firestore.pipeline.Expression regexFind(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first substring of a string expression that matches a + * specified regular expression. + * + * This expression uses the [RE2](https://github.com/google/re2/wiki/Syntax) regular expression + * syntax. + * + * ```kotlin + * // Extract the domain from a lower-cased email address + * regexFind(field("email"), "@[A-Za-z0-9.-]+") + * ``` + * + * @param stringExpression The expression representing the string to search. + * @param pattern The regular expression to search for. + * @return A new [Expression] representing the regular expression find function. + */ + +public static final com.google.firebase.firestore.pipeline.Expression regexFind(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first substring of a string field that matches a + * specified regular expression. + * + * This expression uses the [RE2](https://github.com/google/re2/wiki/Syntax) regular expression + * syntax. + * + * ```kotlin + * // Extract a substring from 'email' based on a pattern stored in another field + * regexFind("email", field("pattern")) + * ``` + * + * @param fieldName The name of the field containing the string to search. + * @param pattern The regular expression to search for. + * @return A new [Expression] representing the regular expression find function. + */ + +public static final com.google.firebase.firestore.pipeline.Expression regexFind(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first substring of a string field that matches a + * specified regular expression. + * + * This expression uses the [RE2](https://github.com/google/re2/wiki/Syntax) regular expression + * syntax. + * + * ```kotlin + * // Extract the domain name from an email field + * regexFind("email", "@[A-Za-z0-9.-]+") + * ``` + * + * @param fieldName The name of the field containing the string to search. + * @param pattern The regular expression to search for. + * @return A new [Expression] representing the regular expression find function. + */ + +public static final com.google.firebase.firestore.pipeline.Expression regexFind(java.lang.String fieldName, java.lang.String pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that evaluates to a list of all substrings in a string expression that + * match a specified regular expression. + * + * This expression uses the [RE2](https://github.com/google/re2/wiki/Syntax) regular expression + * syntax. + * + * ```kotlin + * // Extract all matches based on a dynamic pattern expression + * regexFindAll(field("comment"), field("pattern")) + * ``` + * + * @param stringExpression The expression representing the string to search. + * @param pattern The regular expression to search for. + * @return A new [Expression] that evaluates to a list of matched substrings. + */ + +public static final com.google.firebase.firestore.pipeline.Expression regexFindAll(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that evaluates to a list of all substrings in a string expression that + * match a specified regular expression. + * + * This expression uses the [RE2](https://github.com/google/re2/wiki/Syntax) regular expression + * syntax. + * + * ```kotlin + * // Extract all mentions from a lower-cased comment + * regexFindAll(field("comment"), "@[A-Za-z0-9_]+") + * ``` + * + * @param stringExpression The expression representing the string to search. + * @param pattern The regular expression to search for. + * @return A new [Expression] that evaluates to a list of matched substrings. + */ + +public static final com.google.firebase.firestore.pipeline.Expression regexFindAll(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that evaluates to a list of all substrings in a string field that match + * a specified regular expression. + * + * This expression uses the [RE2](https://github.com/google/re2/wiki/Syntax) regular expression + * syntax. + * + * ```kotlin + * // Extract all matches from 'content' based on a pattern stored in another field + * regexFindAll("content", field("pattern")) + * ``` + * + * @param fieldName The name of the field containing the string to search. + * @param pattern The regular expression to search for. + * @return A new [Expression] that evaluates to a list of matched substrings. + */ + +public static final com.google.firebase.firestore.pipeline.Expression regexFindAll(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that evaluates to a list of all substrings in a string field that match + * a specified regular expression. + * + * This expression uses the [RE2](https://github.com/google/re2/wiki/Syntax) regular expression + * syntax. + * + * ```kotlin + * // Extract all hashtags from a post content field + * regexFindAll("content", "#[A-Za-z0-9_]+") + * ``` + * + * @param fieldName The name of the field containing the string to search. + * @param pattern The regular expression to search for. + * @return A new [Expression] that evaluates to a list of matched substrings. + */ + +public static final com.google.firebase.firestore.pipeline.Expression regexFindAll(java.lang.String fieldName, java.lang.String pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string field matches a specified regular expression. + * + * ```kotlin + * // Check if the 'email' field matches a valid email pattern + * regexMatch(field("email"), "[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}") + * ``` + * + * @param stringExpression The expression representing the string to match against. + * @param pattern The regular expression to use for the match. + * @return A new [BooleanExpression] representing the regular expression match comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression regexMatch(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string field matches a specified regular expression. + * + * ```kotlin + * // Check if the 'email' field matches a valid email pattern + * regexMatch(field("email"), "[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}") + * ``` + * + * @param stringExpression The expression representing the string to match against. + * @param pattern The regular expression to use for the match. + * @return A new [BooleanExpression] representing the regular expression match comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression regexMatch(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string field matches a specified regular expression. + * + * ```kotlin + * // Check if the 'email' field matches the regex from the 'pattern' field. + * regexMatch("email", field("pattern")) + * ``` + * + * @param fieldName The name of the field containing the string. + * @param pattern The regular expression to use for the match. + * @return A new [BooleanExpression] representing the regular expression match comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression regexMatch(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string field matches a specified regular expression. + * + * ```kotlin + * // Check if the 'email' field matches a valid email pattern + * regexMatch("email", "[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}") + * ``` + * + * @param fieldName The name of the field containing the string. + * @param pattern The regular expression to use for the match. + * @return A new [BooleanExpression] representing the regular expression match comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression regexMatch(java.lang.String fieldName, java.lang.String pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the largest value between multiple input expressions or + * literal values. Based on Firestore's value type ordering. + * + * ```kotlin + * // Returns the larger value between the 'timestamp' field and the current timestamp. + * logicalMaximum(field("timestamp"), currentTimestamp()) + * ``` + * + * @param expr The first operand expression. + * @param others Optional additional expressions or literals. + * @return A new [Expression] representing the logical maximum operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression logicalMaximum(com.google.firebase.firestore.pipeline.Expression expr, java.lang.Object... others) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the largest value between multiple input expressions or + * literal values. Based on Firestore's value type ordering. + * + * ```kotlin + * // Returns the larger value between the 'timestamp' field and the current timestamp. + * logicalMaximum("timestamp", currentTimestamp()) + * ``` + * + * @param fieldName The first operand field name. + * @param others Optional additional expressions or literals. + * @return A new [Expression] representing the logical maximum operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression logicalMaximum(java.lang.String fieldName, java.lang.Object... others) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the smallest value between multiple input expressions or + * literal values. Based on Firestore's value type ordering. + * + * ```kotlin + * // Returns the smaller value between the 'timestamp' field and the current timestamp. + * logicalMinimum(field("timestamp"), currentTimestamp()) + * ``` + * + * @param expr The first operand expression. + * @param others Optional additional expressions or literals. + * @return A new [Expression] representing the logical minimum operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression logicalMinimum(com.google.firebase.firestore.pipeline.Expression expr, java.lang.Object... others) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the smallest value between multiple input expressions or + * literal values. Based on Firestore's value type ordering. + * + * ```kotlin + * // Returns the smaller value between the 'timestamp' field and the current timestamp. + * logicalMinimum("timestamp", currentTimestamp()) + * ``` + * + * @param fieldName The first operand field name. + * @param others Optional additional expressions or literals. + * @return A new [Expression] representing the logical minimum operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression logicalMinimum(java.lang.String fieldName, java.lang.Object... others) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that reverses a string. + * + * ```kotlin + * // Reverse the value of the 'myString' field. + * reverse(field("myString")) + * ``` + * + * @param stringExpression An expression evaluating to a string value, which will be reversed. + * @return A new [Expression] representing the reversed string. + */ + +public static final com.google.firebase.firestore.pipeline.Expression reverse(com.google.firebase.firestore.pipeline.Expression stringExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that reverses a string value from the specified field. + * + * ```kotlin + * // Reverse the value of the 'myString' field. + * reverse("myString") + * ``` + * + * @param fieldName The name of the field that contains the string to reverse. + * @return A new [Expression] representing the reversed string. + */ + +public static final com.google.firebase.firestore.pipeline.Expression reverse(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string expression contains a specified substring. + * + * ```kotlin + * // Check if the 'description' field contains the value of the 'keyword' field. + * stringContains(field("description"), field("keyword")) + * ``` + * + * @param stringExpression The expression representing the string to perform the comparison on. + * @param substring The expression representing the substring to search for. + * @return A new [BooleanExpression] representing the contains comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression stringContains(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression substring) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string expression contains a specified substring. + * + * ```kotlin + * // Check if the 'description' field contains "example". + * stringContains(field("description"), "example") + * ``` + * + * @param stringExpression The expression representing the string to perform the comparison on. + * @param substring The substring to search for. + * @return A new [BooleanExpression] representing the contains comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression stringContains(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String substring) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string field contains a specified substring. + * + * ```kotlin + * // Check if the 'description' field contains the value of the 'keyword' field. + * stringContains("description", field("keyword")) + * ``` + * + * @param fieldName The name of the field to perform the comparison on. + * @param substring The expression representing the substring to search for. + * @return A new [BooleanExpression] representing the contains comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression stringContains(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression substring) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string field contains a specified substring. + * + * ```kotlin + * // Check if the 'description' field contains "example". + * stringContains("description", "example") + * ``` + * + * @param fieldName The name of the field to perform the comparison on. + * @param substring The substring to search for. + * @return A new [BooleanExpression] representing the contains comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression stringContains(java.lang.String fieldName, java.lang.String substring) { throw new RuntimeException("Stub!"); } + +/** + * ```kotlin + * // Check if the 'fullName' field starts with the value of the 'firstName' field + * startsWith(field("fullName"), field("firstName")) + * ``` + * + * @param stringExpr The expression to check. + * @param prefix The prefix string expression to check for. + * @return A new [BooleanExpression] representing the 'starts with' comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression startsWith(com.google.firebase.firestore.pipeline.Expression stringExpr, com.google.firebase.firestore.pipeline.Expression prefix) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string expression starts with a given [prefix]. + * + * ```kotlin + * // Check if the 'name' field starts with "Mr." + * startsWith(field("name"), "Mr.") + * ``` + * + * @param stringExpr The expression to check. + * @param prefix The prefix string to check for. + * @return A new [BooleanExpression] representing the 'starts with' comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression startsWith(com.google.firebase.firestore.pipeline.Expression stringExpr, java.lang.String prefix) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string expression starts with a given [prefix]. + * + * ```kotlin + * // Check if the 'fullName' field starts with the value of the 'firstName' field + * startsWith("fullName", field("firstName")) + * ``` + * + * @param fieldName The name of field that contains a string to check. + * @param prefix The prefix string expression to check for. + * @return A new [BooleanExpression] representing the 'starts with' comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression startsWith(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression prefix) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string expression starts with a given [prefix]. + * + * ```kotlin + * // Check if the 'name' field starts with "Mr." + * startsWith("name", "Mr.") + * ``` + * + * @param fieldName The name of field that contains a string to check. + * @param prefix The prefix string to check for. + * @return A new [BooleanExpression] representing the 'starts with' comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression startsWith(java.lang.String fieldName, java.lang.String prefix) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string expression ends with a given [suffix]. + * + * ```kotlin + * // Check if the 'url' field ends with the value of the 'extension' field + * endsWith(field("url"), field("extension")) + * ``` + * + * @param stringExpr The expression to check. + * @param suffix The suffix string expression to check for. + * @return A new [BooleanExpression] representing the 'ends with' comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression endsWith(com.google.firebase.firestore.pipeline.Expression stringExpr, com.google.firebase.firestore.pipeline.Expression suffix) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string expression ends with a given [suffix]. + * + * ```kotlin + * // Check if the 'filename' field ends with ".txt" + * endsWith(field("filename"), ".txt") + * ``` + * + * @param stringExpr The expression to check. + * @param suffix The suffix string to check for. + * @return A new [BooleanExpression] representing the 'ends with' comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression endsWith(com.google.firebase.firestore.pipeline.Expression stringExpr, java.lang.String suffix) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string expression ends with a given [suffix]. + * + * ```kotlin + * // Check if the 'url' field ends with the value of the 'extension' field + * endsWith("url", field("extension")) + * ``` + * + * @param fieldName The name of field that contains a string to check. + * @param suffix The suffix string expression to check for. + * @return A new [BooleanExpression] representing the 'ends with' comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression endsWith(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression suffix) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string expression ends with a given [suffix]. + * + * ```kotlin + * // Check if the 'filename' field ends with ".txt" + * endsWith("filename", ".txt") + * ``` + * + * @param fieldName The name of field that contains a string to check. + * @param suffix The suffix string to check for. + * @return A new [BooleanExpression] representing the 'ends with' comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression endsWith(java.lang.String fieldName, java.lang.String suffix) { throw new RuntimeException("Stub!"); } + +/** + * Reverses the given string expression. + * + * ```kotlin + * // Reverse the value of the 'myString' field. + * stringReverse(field("myString")) + * ``` + * + * @param str The string expression to reverse. + * @return A new [Expression] representing the stringReverse operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression stringReverse(com.google.firebase.firestore.pipeline.Expression str) { throw new RuntimeException("Stub!"); } + +/** + * Reverses the given string field. + * + * ```kotlin + * // Reverse the value of the 'myString' field. + * stringReverse("myString") + * ``` + * + * @param fieldName The name of field that contains the string to reverse. + * @return A new [Expression] representing the stringReverse operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression stringReverse(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a substring of the given string. + * + * ```kotlin + * // Get a substring of the 'message' field starting at index 5 with length 10. + * substring(field("message"), constant(5), constant(10)) + * ``` + * + * @param stringExpression The expression representing the string to get a substring from. + * @param index The starting index of the substring. + * @param length The length of the substring. + * @return A new [Expression] representing the substring. + */ + +public static final com.google.firebase.firestore.pipeline.Expression substring(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression index, com.google.firebase.firestore.pipeline.Expression length) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a substring of the given string. + * + * ```kotlin + * // Get a substring of the 'message' field starting at index 5 with length 10. + * substring("message", 5, 10) + * ``` + * + * @param fieldName The name of the field containing the string to get a substring from. + * @param index The starting index of the substring. + * @param length The length of the substring. + * @return A new [Expression] representing the substring. + */ + +public static final com.google.firebase.firestore.pipeline.Expression substring(java.lang.String fieldName, int index, int length) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that converts a string expression to lowercase. + * + * ```kotlin + * // Convert the 'name' field to lowercase + * toLower(field("name")) + * ``` + * + * @param stringExpression The expression representing the string to convert to lowercase. + * @return A new [Expression] representing the lowercase string. + */ + +public static final com.google.firebase.firestore.pipeline.Expression toLower(com.google.firebase.firestore.pipeline.Expression stringExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that converts a string field to lowercase. + * + * ```kotlin + * // Convert the 'name' field to lowercase + * toLower("name") + * ``` + * + * @param fieldName The name of the field containing the string to convert to lowercase. + * @return A new [Expression] representing the lowercase string. + */ + +public static final com.google.firebase.firestore.pipeline.Expression toLower(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that converts a string expression to uppercase. + * + * ```kotlin + * // Convert the 'title' field to uppercase + * toUpper(field("title")) + * ``` + * + * @param stringExpression The expression representing the string to convert to uppercase. + * @return A new [Expression] representing the uppercase string. + */ + +public static final com.google.firebase.firestore.pipeline.Expression toUpper(com.google.firebase.firestore.pipeline.Expression stringExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that converts a string field to uppercase. + * + * ```kotlin + * // Convert the 'title' field to uppercase + * toUpper("title") + * ``` + * + * @param fieldName The name of the field containing the string to convert to uppercase. + * @return A new [Expression] representing the uppercase string. + */ + +public static final com.google.firebase.firestore.pipeline.Expression toUpper(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes leading and trailing whitespace from a string expression. + * + * ```kotlin + * // Trim whitespace from the 'userInput' field + * trim(field("userInput")) + * ``` + * + * @param stringExpression The expression representing the string to trim. + * @return A new [Expression] representing the trimmed string. + */ + +public static final com.google.firebase.firestore.pipeline.Expression trim(com.google.firebase.firestore.pipeline.Expression stringExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes leading and trailing whitespace from a string field. + * + * ```kotlin + * // Trim whitespace from the 'userInput' field + * trim("userInput") + * ``` + * + * @param fieldName The name of the field containing the string to trim. + * @return A new [Expression] representing the trimmed string. + */ + +public static final com.google.firebase.firestore.pipeline.Expression trim(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes a set of leading and trailing values from an expression. + * + * Note: The values to trim are treated as a **set**, not a substring. + * + * ```kotlin + * // Trim specified characters from the 'userInput' field + * trimValue(field("userInput"), field("valueToTrim")) + * ``` + * + * @param stringExpression The expression representing the string to trim. + * @param valueToTrim The expression evaluated to either a string or a blob. This parameter is + * treated as a set of characters or bytes that will be matched against the input from both + * ends. + * @return A new [Expression] representing the trimmed string or bytes. + */ + +public static final com.google.firebase.firestore.pipeline.Expression trimValue(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression valueToTrim) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes a set of leading and trailing values from a string field. + * + * Note: The values to trim are treated as a **set**, not a substring. + * + * ```kotlin + * // Trim all '-', and '_' characters from the beginning and the end of 'userInput' field + * trimValue("userInput", "-_") + * ``` + * + * @param fieldName The name of the field containing the string to trim. + * @param valueToTrim This parameter is treated as a set of characters or bytes that will be + * matched against the input from both ends. + * @return A new [Expression] representing the trimmed string. + */ + +public static final com.google.firebase.firestore.pipeline.Expression trimValue(java.lang.String fieldName, java.lang.String valueToTrim) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes leading whitespace from a string expression. + * + * ```kotlin + * // Trim leading whitespace from the 'text' field. + * ltrim(field("text")) + * ``` + * + * @param stringExpression The expression representing the string to trim. + * @return A new [Expression] representing the ltrim operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression ltrim(com.google.firebase.firestore.pipeline.Expression stringExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes leading whitespace from a string field. + * + * ```kotlin + * // Trim leading whitespace from the 'text' field. + * ltrim("text") + * ``` + * + * @param fieldName The name of the field containing the string to trim. + * @return A new [Expression] representing the ltrim operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression ltrim(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes a set of leading values from a string expression. + * + * Note: The values to trim are treated as a **set**, not a substring. + * + * ```kotlin + * // Trim all leading '-' and '_' characters from the 'text' field. + * ltrimValue(field("text"), "-_") + * ``` + * + * @param stringExpression The expression representing the string to trim. + * @param valuesToTrim The set of values to remove. + * @return A new [Expression] representing the ltrim operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression ltrimValue(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String valuesToTrim) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes a set of leading values from a string expression. + * + * Note: The values to trim are treated as a **set**, not a substring. + * + * ```kotlin + * // Trim leading characters defined by the 'chars' field from the 'text' field. + * ltrimValue(field("text"), field("chars")) + * ``` + * + * @param stringExpression The expression representing the string to trim. + * @param valuesToTrim The expression representing the set of values to remove. + * @return A new [Expression] representing the ltrim operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression ltrimValue(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression valuesToTrim) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes specified leading values from a string field. + * + * Note: The values to trim are treated as a **set**, not a substring. + * + * ```kotlin + * // Trim all leading '-' and '_' characters from the 'text' field. + * ltrimValue("text", "-_") + * ``` + * + * @param fieldName The name of the field containing the string to trim. + * @param valuesToTrim The set of values to remove. + * @return A new [Expression] representing the ltrim operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression ltrimValue(java.lang.String fieldName, java.lang.String valuesToTrim) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes specified leading values from a string field. + * + * Note: The values to trim are treated as a **set**, not a substring. + * + * ```kotlin + * // Trim leading characters defined by the 'chars' field from the 'text' field. + * ltrimValue("text", field("chars")) + * ``` + * + * @param fieldName The name of the field containing the string to trim. + * @param valuesToTrim The expression representing the set of values to remove. + * @return A new [Expression] representing the ltrim operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression ltrimValue(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression valuesToTrim) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes trailing whitespace from a string expression. + * + * ```kotlin + * // Trim trailing whitespace from the 'text' field. + * rtrim(field("text")) + * ``` + * + * @param stringExpression The expression representing the string to trim. + * @return A new [Expression] representing the rtrim operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression rtrim(com.google.firebase.firestore.pipeline.Expression stringExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes trailing whitespace from a string field. + * + * ```kotlin + * // Trim trailing whitespace from the 'text' field. + * rtrim("text") + * ``` + * + * @param fieldName The name of the field containing the string to trim. + * @return A new [Expression] representing the rtrim operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression rtrim(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes a set of trailing values from a string expression. + * + * Note: The values to trim are treated as a **set**, not a substring. + * + * ```kotlin + * // Trim all trailing '-' and '_' characters from the 'text' field. + * rtrimValue(field("text"), "-_") + * ``` + * + * @param stringExpression The expression representing the string to trim. + * @param valuesToTrim The set of values to remove. + * @return A new [Expression] representing the rtrim operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression rtrimValue(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String valuesToTrim) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes a set of trailing values from a string expression. + * + * Note: The values to trim are treated as a **set**, not a substring. + * + * ```kotlin + * // Trim trailing characters defined by the 'chars' field from the 'text' field. + * rtrimValue(field("text"), field("chars")) + * ``` + * + * @param stringExpression The expression representing the string to trim. + * @param valuesToTrim The expression representing the set of values to remove. + * @return A new [Expression] representing the rtrim operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression rtrimValue(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression valuesToTrim) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes a set of trailing values from a string field. + * + * Note: The values to trim are treated as a **set**, not a substring. + * + * ```kotlin + * // Trim all trailing '-' and '_' characters from the 'text' field. + * rtrimValue("text", "-_") + * ``` + * + * @param fieldName The name of the field containing the string to trim. + * @param valuesToTrim The set of values to remove. + * @return A new [Expression] representing the rtrim operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression rtrimValue(java.lang.String fieldName, java.lang.String valuesToTrim) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes a set of trailing values from a string field. + * + * Note: The values to trim are treated as a **set**, not a substring. + * + * ```kotlin + * // Trim trailing characters defined by the 'chars' field from the 'text' field. + * rtrimValue("text", field("chars")) + * ``` + * + * @param fieldName The name of the field containing the string to trim. + * @param valuesToTrim The expression representing the set of values to remove. + * @return A new [Expression] representing the rtrim operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression rtrimValue(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression valuesToTrim) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that repeats a string expression a given number of times. + * + * ```kotlin + * // Repeat the 'name' field 3 times. + * stringRepeat(field("name"), 3) + * ``` + * + * @param stringExpression The expression representing the string to repeat. + * @param count The number of times to repeat the string. + * @return A new [Expression] representing the stringRepeat operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression stringRepeat(com.google.firebase.firestore.pipeline.Expression stringExpression, int count) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that repeats a string expression a given number of times. + * + * ```kotlin + * // Repeat the 'name' field the number of times specified in the 'count' field. + * stringRepeat(field("name"), field("count")) + * ``` + * + * @param stringExpression The expression representing the string to repeat. + * @param count The expression representing the number of times to repeat the string. + * @return A new [Expression] representing the stringRepeat operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression stringRepeat(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression count) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that repeats a string field a given number of times. + * + * ```kotlin + * // Repeat the 'name' field 3 times. + * stringRepeat("name", 3) + * ``` + * + * @param fieldName The name of the field containing the string to repeat. + * @param count The number of times to repeat the string. + * @return A new [Expression] representing the stringRepeat operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression stringRepeat(java.lang.String fieldName, int count) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that repeats a string field a given number of times. + * + * ```kotlin + * // Repeat the 'name' field the number of times specified in the 'count' field. + * stringRepeat("name", field("count")) + * ``` + * + * @param fieldName The name of the field containing the string to repeat. + * @param count The expression representing the number of times to repeat the string. + * @return A new [Expression] representing the stringRepeat operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression stringRepeat(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression count) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that replaces all occurrences of a substring with another string. + * + * ```kotlin + * // Replace all occurrences of the 'old' field with the 'new' field in 'text'. + * stringReplaceAll(field("text"), field("old"), field("new")) + * ``` + * + * @param stringExpression The expression representing the original string. + * @param oldValue The expression representing the substring to replace. + * @param newValue The expression representing the replacement string. + * @return A new [Expression] representing the stringReplaceAll operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression stringReplaceAll(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression oldValue, com.google.firebase.firestore.pipeline.Expression newValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that replaces all occurrences of a substring with another string. + * + * ```kotlin + * // Replace all occurrences of "cat" with "dog" in the 'text' field. + * stringReplaceAll(field("text"), "cat", "dog") + * ``` + * + * @param stringExpression The expression representing the original string. + * @param oldValue The substring to replace. + * @param newValue The replacement string. + * @return A new [Expression] representing the stringReplaceAll operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression stringReplaceAll(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String oldValue, java.lang.String newValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that replaces all occurrences of a substring with another string in a + * field. + * + * ```kotlin + * // Replace all occurrences of the 'old' field with the 'new' field in 'text'. + * stringReplaceAll("text", field("old"), field("new")) + * ``` + * + * @param fieldName The name of the field containing the original string. + * @param oldValue The expression representing the substring to replace. + * @param newValue The expression representing the replacement string. + * @return A new [Expression] representing the stringReplaceAll operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression stringReplaceAll(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression oldValue, com.google.firebase.firestore.pipeline.Expression newValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that replaces all occurrences of a substring with another string in a + * field. + * + * ```kotlin + * // Replace all occurrences of "cat" with "dog" in the 'text' field. + * stringReplaceAll("text", "cat", "dog") + * ``` + * + * @param fieldName The name of the field containing the original string. + * @param oldValue The substring to replace. + * @param newValue The replacement string. + * @return A new [Expression] representing the stringReplaceAll operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression stringReplaceAll(java.lang.String fieldName, java.lang.String oldValue, java.lang.String newValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that replaces the first occurrence of a substring with another string. + * + * ```kotlin + * // Replace the first occurrence of the 'old' field with the 'new' field in 'text'. + * stringReplaceOne(field("text"), field("old"), field("new")) + * ``` + * + * @param stringExpression The expression representing the original string. + * @param oldValue The expression representing the substring to replace. + * @param newValue The expression representing the replacement string. + * @return A new [Expression] representing the stringReplaceOne operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression stringReplaceOne(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression oldValue, com.google.firebase.firestore.pipeline.Expression newValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that replaces the first occurrence of a substring with another string. + * + * ```kotlin + * // Replace the first occurrence of "cat" with "dog" in the 'text' field. + * stringReplaceOne(field("text"), "cat", "dog") + * ``` + * + * @param stringExpression The expression representing the original string. + * @param oldValue The substring to replace. + * @param newValue The replacement string. + * @return A new [Expression] representing the stringReplaceOne operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression stringReplaceOne(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String oldValue, java.lang.String newValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that replaces the first occurrence of a substring with another string + * in a field. + * + * ```kotlin + * // Replace the first occurrence of the 'old' field with the 'new' field in 'text'. + * stringReplaceOne("text", field("old"), field("new")) + * ``` + * + * @param fieldName The name of the field containing the original string. + * @param oldValue The expression representing the substring to replace. + * @param newValue The expression representing the replacement string. + * @return A new [Expression] representing the stringReplaceOne operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression stringReplaceOne(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression oldValue, com.google.firebase.firestore.pipeline.Expression newValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that replaces the first occurrence of a substring with another string + * in a field. + * + * ```kotlin + * // Replace the first occurrence of "cat" with "dog" in the 'text' field. + * stringReplaceOne("text", "cat", "dog") + * ``` + * + * @param fieldName The name of the field containing the original string. + * @param oldValue The substring to replace. + * @param newValue The replacement string. + * @return A new [Expression] representing the stringReplaceOne operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression stringReplaceOne(java.lang.String fieldName, java.lang.String oldValue, java.lang.String newValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the 0-based index of the first occurrence of the specified + * substring. + * + * ```kotlin + * // Get the index of the 'search' field within the 'text' field. + * stringIndexOf(field("text"), field("search")) + * ``` + * + * @param stringExpression The expression representing the string to search within. + * @param substring The expression representing the substring to search for. + * @return A new [Expression] representing the stringIndexOf operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression stringIndexOf(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression substring) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the 0-based index of the first occurrence of the specified + * substring. + * + * ```kotlin + * // Get the index of "world" within the 'text' field. + * stringIndexOf(field("text"), "world") + * ``` + * + * @param stringExpression The expression representing the string to search within. + * @param substring The substring to search for. + * @return A new [Expression] representing the stringIndexOf operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression stringIndexOf(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String substring) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the 0-based index of the first occurrence of the specified + * substring in a field. + * + * ```kotlin + * // Get the index of the 'search' field within the 'text' field. + * stringIndexOf("text", field("search")) + * ``` + * + * @param fieldName The name of the field containing the string to search within. + * @param substring The expression representing the substring to search for. + * @return A new [Expression] representing the stringIndexOf operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression stringIndexOf(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression substring) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the 0-based index of the first occurrence of the specified + * substring in a field. + * + * ```kotlin + * // Get the index of "world" within the 'text' field. + * stringIndexOf("text", "world") + * ``` + * + * @param fieldName The name of the field containing the string to search within. + * @param substring The substring to search for. + * @return A new [Expression] representing the stringIndexOf operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression stringIndexOf(java.lang.String fieldName, java.lang.String substring) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that concatenates string expressions together. + * + * ```kotlin + * // Combine the 'firstName', " ", and 'lastName' fields into a single string + * stringConcat(field("firstName"), constant(" "), field("lastName")) + * ``` + * + * @param firstString The expression representing the initial string value. + * @param otherStrings Optional additional string expressions to concatenate. + * @return A new [Expression] representing the concatenated string. + */ + +public static final com.google.firebase.firestore.pipeline.Expression stringConcat(com.google.firebase.firestore.pipeline.Expression firstString, com.google.firebase.firestore.pipeline.Expression... otherStrings) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that concatenates string expressions together. + * + * ```kotlin + * // Combine the 'firstName', " ", and 'lastName' fields into a single string + * stringConcat(field("firstName"), " ", field("lastName")) + * ``` + * + * @param firstString The expression representing the initial string value. + * @param otherStrings Optional additional string expressions or string constants to + * concatenate. + * @return A new [Expression] representing the concatenated string. + */ + +public static final com.google.firebase.firestore.pipeline.Expression stringConcat(com.google.firebase.firestore.pipeline.Expression firstString, java.lang.Object... otherStrings) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that concatenates string expressions together. + * + * ```kotlin + * // Combine the 'firstName', " ", and 'lastName' fields into a single string + * stringConcat("firstName", constant(" "), field("lastName")) + * ``` + * + * @param fieldName The field name containing the initial string value. + * @param otherStrings Optional additional string expressions to concatenate. + * @return A new [Expression] representing the concatenated string. + */ + +public static final com.google.firebase.firestore.pipeline.Expression stringConcat(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression... otherStrings) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that concatenates string expressions together. + * + * ```kotlin + * // Combine the 'firstName', " ", and 'lastName' fields into a single string + * stringConcat("firstName", " ", "lastName") + * ``` + * + * @param fieldName The field name containing the initial string value. + * @param otherStrings Optional additional string expressions or string constants to + * concatenate. + * @return A new [Expression] representing the concatenated string. + */ + +public static final com.google.firebase.firestore.pipeline.Expression stringConcat(java.lang.String fieldName, java.lang.Object... otherStrings) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that creates a Firestore map value from an input object. + * + * ```kotlin + * // Create a map with a constant key and a field value + * map(mapOf("name" to field("productName"), "quantity" to 1)) + * ``` + * + * @param elements The input map to evaluate in the expression. + * @return A new [Expression] representing the map function. + */ + +public static final com.google.firebase.firestore.pipeline.Expression map(java.util.Map elements) { throw new RuntimeException("Stub!"); } + +/** + * Accesses a field/property of a document or Map using the provided [key]. + * + * @param expression The expression evaluating to a map or document. + * @param key The key of the field to access. + * @return An [Expression] representing the value of the field. + */ + +public static final com.google.firebase.firestore.pipeline.Expression getField(com.google.firebase.firestore.pipeline.Expression expression, java.lang.String key) { throw new RuntimeException("Stub!"); } + +/** + * Accesses a field/property of a document or Map using the provided [key]. + * + * @param fieldName The field name of the map or document field. + * @param key The key of the field to access. + * @return An [Expression] representing the value of the field. + */ + +public static final com.google.firebase.firestore.pipeline.Expression getField(java.lang.String fieldName, java.lang.String key) { throw new RuntimeException("Stub!"); } + +/** + * Accesses a field/property of a document or Map using the provided [keyExpression]. + * + * @param expression The expression evaluating to a Map or Document. + * @param keyExpression The expression evaluating to the key. + * @return A new [Expression] representing the value of the field. + */ + +public static final com.google.firebase.firestore.pipeline.Expression getField(com.google.firebase.firestore.pipeline.Expression expression, com.google.firebase.firestore.pipeline.Expression keyExpression) { throw new RuntimeException("Stub!"); } + +/** + * Accesses a field/property of a document or Map using the provided [keyExpression]. + * + * @param fieldName The field name of the map or document field. + * @param keyExpression The expression evaluating to the key. + * @return A new [Expression] representing the value of the field. + */ + +public static final com.google.firebase.firestore.pipeline.Expression getField(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression keyExpression) { throw new RuntimeException("Stub!"); } + +/** + * Accesses a value from a map (object) field using the provided [key]. + * + * ```kotlin + * // Get the 'city' value from the 'address' map field + * mapGet(field("address"), "city") + * ``` + * + * @param mapExpression The expression representing the map. + * @param key The key to access in the map. + * @return A new [Expression] representing the value associated with the given key in the map. + */ + +public static final com.google.firebase.firestore.pipeline.Expression mapGet(com.google.firebase.firestore.pipeline.Expression mapExpression, java.lang.String key) { throw new RuntimeException("Stub!"); } + +/** + * Accesses a value from a map (object) field using the provided [key]. + * + * ```kotlin + * // Get the 'city' value from the 'address' map field + * mapGet("address", "city") + * ``` + * + * @param fieldName The field name of the map field. + * @param key The key to access in the map. + * @return A new [Expression] representing the value associated with the given key in the map. + */ + +public static final com.google.firebase.firestore.pipeline.Expression mapGet(java.lang.String fieldName, java.lang.String key) { throw new RuntimeException("Stub!"); } + +/** + * Accesses a value from a map (object) field using the provided [keyExpression]. + * + * ```kotlin + * // Get the value from the 'address' map field, using the key from the 'keyField' field + * mapGet(field("address"), field("keyField")) + * ``` + * + * @param mapExpression The expression representing the map. + * @param keyExpression The key to access in the map. + * @return A new [Expression] representing the value associated with the given key in the map. + */ + +public static final com.google.firebase.firestore.pipeline.Expression mapGet(com.google.firebase.firestore.pipeline.Expression mapExpression, com.google.firebase.firestore.pipeline.Expression keyExpression) { throw new RuntimeException("Stub!"); } + +/** + * Accesses a value from a map (object) field using the provided [keyExpression]. + * + * ```kotlin + * // Get the value from the 'address' map field, using the key from the 'keyField' field + * mapGet("address", field("keyField")) + * ``` + * + * @param fieldName The field name of the map field. + * @param keyExpression The key to access in the map. + * @return A new [Expression] representing the value associated with the given key in the map. + */ + +public static final com.google.firebase.firestore.pipeline.Expression mapGet(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression keyExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that merges multiple maps into a single map. If multiple maps have the + * same key, the later value is used. + * + * ```kotlin + * // Merges the map in the settings field with, a map literal, and a map in + * // that is conditionally returned by another expression + * mapMerge( + * field("settings"), + * map(mapOf("enabled" to true)), + * conditional( + * field("isAdmin").equal(true), + * map(mapOf("admin" to true)), + * map(emptyMap()) + * ) + * ) + * ``` + * + * @param firstMap First map expression that will be merged. + * @param secondMap Second map expression that will be merged. + * @param otherMaps Additional maps to merge. + * @return A new [Expression] representing the mapMerge operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression mapMerge(com.google.firebase.firestore.pipeline.Expression firstMap, com.google.firebase.firestore.pipeline.Expression secondMap, com.google.firebase.firestore.pipeline.Expression... otherMaps) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that merges multiple maps into a single map. If multiple maps have the + * same key, the later value is used. + * + * ```kotlin + * // Merges the map in the settings field with, a map literal, and a map in + * // that is conditionally returned by another expression + * mapMerge( + * "settings", + * map(mapOf("enabled" to true)), + * conditional( + * field("isAdmin").equal(true), + * map(mapOf("admin" to true)), + * map(emptyMap()) + * ) + * ) + * ``` + * + * @param firstMapFieldName First map field name that will be merged. + * @param secondMap Second map expression that will be merged. + * @param otherMaps Additional maps to merge. + * @return A new [Expression] representing the mapMerge operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression mapMerge(java.lang.String firstMapFieldName, com.google.firebase.firestore.pipeline.Expression secondMap, com.google.firebase.firestore.pipeline.Expression... otherMaps) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes a key from the map produced by evaluating an expression. + * + * ```kotlin + * // Removes the key 'baz' from the input map. + * mapRemove(map(mapOf("foo" to "bar", "baz" to true)), constant("baz")) + * ``` + * + * @param mapExpr An expression that evaluates to a map. + * @param key The name of the key to remove from the input map. + * @return A new [Expression] that evaluates to a modified map. + */ + +public static final com.google.firebase.firestore.pipeline.Expression mapRemove(com.google.firebase.firestore.pipeline.Expression mapExpr, com.google.firebase.firestore.pipeline.Expression key) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes a key from the map produced by evaluating an expression. + * + * ```kotlin + * // Removes the key 'city' field from the map in the address field of the input document. + * mapRemove("address", constant("city")) + * ``` + * + * @param mapField The name of a field containing a map value. + * @param key The name of the key to remove from the input map. + * @return A new [Expression] that evaluates to a modified map. + */ + +public static final com.google.firebase.firestore.pipeline.Expression mapRemove(java.lang.String mapField, com.google.firebase.firestore.pipeline.Expression key) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes a key from the map produced by evaluating an expression. + * + * ```kotlin + * // Removes the key 'baz' from the input map. + * mapRemove(map(mapOf("foo" to "bar", "baz" to true)), "baz") + * ``` + * + * @param mapExpr An expression that evaluates to a map. + * @param key The name of the key to remove from the input map. + * @return A new [Expression] that evaluates to a modified map. + */ + +public static final com.google.firebase.firestore.pipeline.Expression mapRemove(com.google.firebase.firestore.pipeline.Expression mapExpr, java.lang.String key) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes a key from the map produced by evaluating an expression. + * + * ```kotlin + * // Removes the key 'city' field from the map in the address field of the input document. + * mapRemove("address", "city") + * ``` + * + * @param mapField The name of a field containing a map value. + * @param key The name of the key to remove from the input map. + * @return A new [Expression] that evaluates to a modified map. + */ + +public static final com.google.firebase.firestore.pipeline.Expression mapRemove(java.lang.String mapField, java.lang.String key) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a new map with the specified entries added or updated. + * + * Note: This only performs shallow updates to the map. Setting a value to `null` will retain + * the key with a `null` value. To remove a key entirely, use `mapRemove`. + * + * ```kotlin + * // Set the 'city' to "San Francisco" in the 'address' map + * mapSet(field("address"), constant("city"), constant("San Francisco")); + * ``` + * + * @param mapExpr The expression representing the map. + * @param key The key to set. Must be an expression representing a string. + * @param value The value to set. + * @param moreKeyValues Additional key-value pairs to set. + * @return A new [Expression] representing the map with the entries set. + */ + +public static final com.google.firebase.firestore.pipeline.Expression mapSet(com.google.firebase.firestore.pipeline.Expression mapExpr, com.google.firebase.firestore.pipeline.Expression key, com.google.firebase.firestore.pipeline.Expression value, com.google.firebase.firestore.pipeline.Expression... moreKeyValues) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a new map with the specified entries added or updated. + * + * Note: This only performs shallow updates to the map. Setting a value to `null` will retain + * the key with a `null` value. To remove a key entirely, use `mapRemove`. + * + * ```kotlin + * // Set the 'city' to "San Francisco" in the 'address' map + * mapSet(field("address"), "city", "San Francisco"); + * ``` + * + * @param mapExpr The map field to set entries in. + * @param key The key to set. + * @param value The value to set. + * @param moreKeyValues Additional key-value pairs to set. + * @return A new [Expression] representing the map with the entries set. + */ + +public static final com.google.firebase.firestore.pipeline.Expression mapSet(com.google.firebase.firestore.pipeline.Expression mapExpr, java.lang.String key, java.lang.Object value, java.lang.Object... moreKeyValues) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a new map with the specified entries added or updated. + * + * Note: This only performs shallow updates to the map. Setting a value to `null` will retain + * the key with a `null` value. To remove a key entirely, use `mapRemove`. + * + * ```kotlin + * // Set the 'city' to "San Francisco" in the 'address' map + * mapSet("address", constant("city"), constant("San Francisco")) + * ``` + * + * @param mapField The map field to set entries in. + * @param key The key to set. Must be an expression representing a string. + * @param value The value to set. + * @param moreKeyValues Additional key-value pairs to set. + * @return A new [Expression] representing the map with the entries set. + */ + +public static final com.google.firebase.firestore.pipeline.Expression mapSet(java.lang.String mapField, com.google.firebase.firestore.pipeline.Expression key, com.google.firebase.firestore.pipeline.Expression value, com.google.firebase.firestore.pipeline.Expression... moreKeyValues) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a new map with the specified entries added or updated. + * + * Note: This only performs shallow updates to the map. Setting a value to `null` will retain + * the key with a `null` value. To remove a key entirely, use `mapRemove`. + * + * ```kotlin + * // Set the 'city' to "San Francisco" in the 'address' map + * mapSet("address", "city", "San Francisco") + * ``` + * + * @param mapField The map field to set entries in. + * @param key The key to set. Must be an expression representing a string. + * @param value The value to set. + * @param moreKeyValues Additional key-value pairs to set. + * @return A new [Expression] representing the map with the entries set. + */ + +public static final com.google.firebase.firestore.pipeline.Expression mapSet(java.lang.String mapField, java.lang.String key, java.lang.Object value, java.lang.Object... moreKeyValues) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the keys of a map. + * + * Note: While the backend generally preserves insertion order, relying on the order of the + * output array is not guaranteed and should be avoided. + * + * ```kotlin + * // Get the keys of a map expression. + * mapKeys(map(mapOf("a" to 1, "b" to 2))) + * ``` + * + * @param mapExpr The expression representing the map to get the keys of. + * @return A new [Expression] representing the keys of the map. + */ + +public static final com.google.firebase.firestore.pipeline.Expression mapKeys(com.google.firebase.firestore.pipeline.Expression mapExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the keys of a map. + * + * Note: While the backend generally preserves insertion order, relying on the order of the + * output array is not guaranteed and should be avoided. + * + * ```kotlin + * // Get the keys of the 'metadata' map field. + * mapKeys("metadata") + * ``` + * + * @param mapField The map field to get the keys of. + * @return A new [Expression] representing the keys of the map. + */ + +public static final com.google.firebase.firestore.pipeline.Expression mapKeys(java.lang.String mapField) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the values of a map. + * + * Note: While the backend generally preserves insertion order, relying on the order of the + * output array is not guaranteed and should be avoided. + * + * ```kotlin + * // Get the values of a map expression. + * mapValues(map(mapOf("a" to 1, "b" to 2))) + * ``` + * + * @param mapExpr The expression representing the map to get the values of. + * @return A new [Expression] representing the values of the map. + */ + +public static final com.google.firebase.firestore.pipeline.Expression mapValues(com.google.firebase.firestore.pipeline.Expression mapExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the values of a map. + * + * Note: While the backend generally preserves insertion order, relying on the order of the + * output array is not guaranteed and should be avoided. + * + * ```kotlin + * // Get the values of the 'metadata' map field. + * mapValues("metadata") + * ``` + * + * @param mapField The map field to get the values of. + * @return A new [Expression] representing the values of the map. + */ + +public static final com.google.firebase.firestore.pipeline.Expression mapValues(java.lang.String mapField) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the entries of a map as an array of maps, where each map + * contains a "k" property for the key and a "v" property for the value. + * + * Note: While the backend generally preserves insertion order, relying on the order of the + * output array is not guaranteed and should be avoided. + * + * ```kotlin + * // Get the entries of a map expression. + * mapEntries(map(mapOf("a" to 1, "b" to 2))) + * ``` + * + * @param mapExpr The expression representing the map to get the entries of. + * @return A new [Expression] representing the entries of the map. + */ + +public static final com.google.firebase.firestore.pipeline.Expression mapEntries(com.google.firebase.firestore.pipeline.Expression mapExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the entries of a map as an array of maps. + * + * Note: While the backend generally preserves insertion order, relying on the order of the + * output array is not guaranteed and should be avoided. + * + * ```kotlin + * // Get the entries of the 'metadata' map field. + * mapEntries("metadata") + * ``` + * + * @param mapField The map field to get the entries of. + * @return A new [Expression] representing the entries of the map. + */ + +public static final com.google.firebase.firestore.pipeline.Expression mapEntries(java.lang.String mapField) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the Cosine distance between two vector expressions. + * + * ```kotlin + * // Calculate the cosine distance between the 'userVector' field and the 'itemVector' field + * cosineDistance(field("userVector"), field("itemVector")) + * ``` + * + * @param vector1 The first vector (represented as an Expression) to compare against. + * @param vector2 The other vector (represented as an Expression) to compare against. + * @return A new [Expression] representing the cosine distance between the two vectors. + */ + +public static final com.google.firebase.firestore.pipeline.Expression cosineDistance(com.google.firebase.firestore.pipeline.Expression vector1, com.google.firebase.firestore.pipeline.Expression vector2) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the Cosine distance between vector expression and a vector literal. + * + * ```kotlin + * // Calculate the Cosine distance between the 'location' field and a target location + * cosineDistance(field("location"), doubleArrayOf(37.7749, -122.4194)) + * ``` + * + * @param vector1 The first vector (represented as an Expression) to compare against. + * @param vector2 The other vector (as an array of doubles) to compare against. + * @return A new [Expression] representing the cosine distance between the two vectors. + */ + +public static final com.google.firebase.firestore.pipeline.Expression cosineDistance(com.google.firebase.firestore.pipeline.Expression vector1, double[] vector2) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the Cosine distance between vector expression and a vector literal. + * + * ```kotlin + * // Calculate the Cosine distance between the 'location' field and a target location + * cosineDistance(field("location"), VectorValue.from(listOf(37.7749, -122.4194))) + * ``` + * + * @param vector1 The first vector (represented as an [Expression]) to compare against. + * @param vector2 The other vector (represented as an [VectorValue]) to compare against. + * @return A new [Expression] representing the cosine distance between the two vectors. + */ + +public static final com.google.firebase.firestore.pipeline.Expression cosineDistance(com.google.firebase.firestore.pipeline.Expression vector1, com.google.firebase.firestore.VectorValue vector2) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the Cosine distance between a vector field and a vector expression. + * + * ```kotlin + * // Calculate the cosine distance between the 'userVector' field and the 'itemVector' field + * cosineDistance("userVector", field("itemVector")) + * ``` + * + * @param vectorFieldName The name of the field containing the first vector. + * @param vector The other vector (represented as an Expression) to compare against. + * @return A new [Expression] representing the cosine distance between the two vectors. + */ + +public static final com.google.firebase.firestore.pipeline.Expression cosineDistance(java.lang.String vectorFieldName, com.google.firebase.firestore.pipeline.Expression vector) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the Cosine distance between a vector field and a vector literal. + * + * ```kotlin + * // Calculate the Cosine distance between the 'location' field and a target location + * cosineDistance("location", doubleArrayOf(37.7749, -122.4194)) + * ``` + * + * @param vectorFieldName The name of the field containing the first vector. + * @param vector The other vector (as an array of doubles) to compare against. + * @return A new [Expression] representing the cosine distance between the two vectors. + */ + +public static final com.google.firebase.firestore.pipeline.Expression cosineDistance(java.lang.String vectorFieldName, double[] vector) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the Cosine distance between a vector field and a vector literal. + * + * ```kotlin + * // Calculate the Cosine distance between the 'location' field and a target location + * cosineDistance("location", VectorValue.from(listOf(37.7749, -122.4194))) + * ``` + * + * @param vectorFieldName The name of the field containing the first vector. + * @param vector The other vector (represented as an [VectorValue]) to compare against. + * @return A new [Expression] representing the cosine distance between the two vectors. + */ + +public static final com.google.firebase.firestore.pipeline.Expression cosineDistance(java.lang.String vectorFieldName, com.google.firebase.firestore.VectorValue vector) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the dot product distance between two vector expressions. + * + * ```kotlin + * // Calculate the dot product between the 'userVector' field and the 'itemVector' field + * dotProduct(field("userVector"), field("itemVector")) + * ``` + * + * @param vector1 The first vector (represented as an Expression) to compare against. + * @param vector2 The other vector (represented as an Expression) to compare against. + * @return A new [Expression] representing the dot product distance between the two vectors. + */ + +public static final com.google.firebase.firestore.pipeline.Expression dotProduct(com.google.firebase.firestore.pipeline.Expression vector1, com.google.firebase.firestore.pipeline.Expression vector2) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the dot product distance between vector expression and a vector literal. + * + * ```kotlin + * // Calculate the dot product between the 'vector' field and a constant vector + * dotProduct(field("vector"), doubleArrayOf(1.0, 2.0, 3.0)) + * ``` + * + * @param vector1 The first vector (represented as an Expression) to compare against. + * @param vector2 The other vector (as an array of doubles) to compare against. + * @return A new [Expression] representing the dot product distance between the two vectors. + */ + +public static final com.google.firebase.firestore.pipeline.Expression dotProduct(com.google.firebase.firestore.pipeline.Expression vector1, double[] vector2) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the dot product distance between vector expression and a vector literal. + * + * ```kotlin + * // Calculate the dot product between the 'vector' field and a constant vector + * dotProduct(field("vector"), VectorValue.from(listOf(1.0, 2.0, 3.0))) + * ``` + * + * @param vector1 The first vector (represented as an [Expression]) to compare against. + * @param vector2 The other vector (represented as an [VectorValue]) to compare against. + * @return A new [Expression] representing the dot product distance between the two vectors. + */ + +public static final com.google.firebase.firestore.pipeline.Expression dotProduct(com.google.firebase.firestore.pipeline.Expression vector1, com.google.firebase.firestore.VectorValue vector2) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the dot product distance between a vector field and a vector expression. + * + * ```kotlin + * // Calculate the dot product between the 'userVector' field and the 'itemVector' field + * dotProduct("userVector", field("itemVector")) + * ``` + * + * @param vectorFieldName The name of the field containing the first vector. + * @param vector The other vector (represented as an Expression) to compare against. + * @return A new [Expression] representing the dot product distance between the two vectors. + */ + +public static final com.google.firebase.firestore.pipeline.Expression dotProduct(java.lang.String vectorFieldName, com.google.firebase.firestore.pipeline.Expression vector) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the dot product distance between vector field and a vector literal. + * + * ```kotlin + * // Calculate the dot product between the 'vector' field and a constant vector + * dotProduct("vector", doubleArrayOf(1.0, 2.0, 3.0)) + * ``` + * + * @param vectorFieldName The name of the field containing the first vector. + * @param vector The other vector (as an array of doubles) to compare against. + * @return A new [Expression] representing the dot product distance between the two vectors. + */ + +public static final com.google.firebase.firestore.pipeline.Expression dotProduct(java.lang.String vectorFieldName, double[] vector) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the dot product distance between a vector field and a vector literal. + * + * ```kotlin + * // Calculate the dot product between the 'vector' field and a constant vector + * dotProduct("vector", VectorValue.from(listOf(1.0, 2.0, 3.0))) + * ``` + * + * @param vectorFieldName The name of the field containing the first vector. + * @param vector The other vector (represented as an [VectorValue]) to compare against. + * @return A new [Expression] representing the dot product distance between the two vectors. + */ + +public static final com.google.firebase.firestore.pipeline.Expression dotProduct(java.lang.String vectorFieldName, com.google.firebase.firestore.VectorValue vector) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the Euclidean distance between two vector expressions. + * + * ```kotlin + * // Calculate the Euclidean distance between the 'userVector' field and the 'itemVector' field + * euclideanDistance(field("userVector"), field("itemVector")) + * ``` + * + * @param vector1 The first vector (represented as an Expression) to compare against. + * @param vector2 The other vector (represented as an Expression) to compare against. + * @return A new [Expression] representing the Euclidean distance between the two vectors. + */ + +public static final com.google.firebase.firestore.pipeline.Expression euclideanDistance(com.google.firebase.firestore.pipeline.Expression vector1, com.google.firebase.firestore.pipeline.Expression vector2) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the Euclidean distance between vector expression and a vector literal. + * + * ```kotlin + * // Calculate the Euclidean distance between the 'vector' field and a constant vector + * euclideanDistance(field("vector"), doubleArrayOf(1.0, 2.0, 3.0)) + * ``` + * + * @param vector1 The first vector (represented as an Expression) to compare against. + * @param vector2 The other vector (as an array of doubles) to compare against. + * @return A new [Expression] representing the Euclidean distance between the two vectors. + */ + +public static final com.google.firebase.firestore.pipeline.Expression euclideanDistance(com.google.firebase.firestore.pipeline.Expression vector1, double[] vector2) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the Euclidean distance between vector expression and a vector literal. + * + * ```kotlin + * // Calculate the Euclidean distance between the 'vector' field and a constant vector + * euclideanDistance(field("vector"), VectorValue.from(listOf(1.0, 2.0, 3.0))) + * ``` + * + * @param vector1 The first vector (represented as an [Expression]) to compare against. + * @param vector2 The other vector (represented as an [VectorValue]) to compare against. + * @return A new [Expression] representing the Euclidean distance between the two vectors. + */ + +public static final com.google.firebase.firestore.pipeline.Expression euclideanDistance(com.google.firebase.firestore.pipeline.Expression vector1, com.google.firebase.firestore.VectorValue vector2) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the Euclidean distance between a vector field and a vector expression. + * + * ```kotlin + * // Calculate the Euclidean distance between the 'userVector' field and the 'itemVector' field + * euclideanDistance("userVector", field("itemVector")) + * ``` + * + * @param vectorFieldName The name of the field containing the first vector. + * @param vector The other vector (represented as an Expression) to compare against. + * @return A new [Expression] representing the Euclidean distance between the two vectors. + */ + +public static final com.google.firebase.firestore.pipeline.Expression euclideanDistance(java.lang.String vectorFieldName, com.google.firebase.firestore.pipeline.Expression vector) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the Euclidean distance between a vector field and a vector literal. + * + * ```kotlin + * // Calculate the Euclidean distance between the 'vector' field and a constant vector + * euclideanDistance("vector", doubleArrayOf(1.0, 2.0, 3.0)) + * ``` + * + * @param vectorFieldName The name of the field containing the first vector. + * @param vector The other vector (as an array of doubles) to compare against. + * @return A new [Expression] representing the Euclidean distance between the two vectors. + */ + +public static final com.google.firebase.firestore.pipeline.Expression euclideanDistance(java.lang.String vectorFieldName, double[] vector) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the Euclidean distance between a vector field and a vector literal. + * + * ```kotlin + * // Calculate the Euclidean distance between the 'vector' field and a constant vector + * euclideanDistance("vector", VectorValue.from(listOf(1.0, 2.0, 3.0))) + * ``` + * + * @param vectorFieldName The name of the field containing the first vector. + * @param vector The other vector (represented as an [VectorValue]) to compare against. + * @return A new [Expression] representing the Euclidean distance between the two vectors. + */ + +public static final com.google.firebase.firestore.pipeline.Expression euclideanDistance(java.lang.String vectorFieldName, com.google.firebase.firestore.VectorValue vector) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the length (dimension) of a Firestore Vector. + * + * ```kotlin + * // Get the vector length (dimension) of the field 'embedding'. + * vectorLength(field("embedding")) + * ``` + * + * @param vectorExpression The expression representing the Firestore Vector. + * @return A new [Expression] representing the length (dimension) of the vector. + */ + +public static final com.google.firebase.firestore.pipeline.Expression vectorLength(com.google.firebase.firestore.pipeline.Expression vectorExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the length (dimension) of a Firestore Vector. + * + * ```kotlin + * // Get the vector length (dimension) of the field 'embedding'. + * vectorLength("embedding") + * ``` + * + * @param fieldName The name of the field containing the Firestore Vector. + * @return A new [Expression] representing the length (dimension) of the vector. + */ + +public static final com.google.firebase.firestore.pipeline.Expression vectorLength(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that evaluates to the current server timestamp. + * + * ```kotlin + * // Get the current server timestamp + * currentTimestamp() + * ``` + * + * @return A new [Expression] representing the current server timestamp. + */ + +public static final com.google.firebase.firestore.pipeline.Expression currentTimestamp() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that interprets an expression as the number of microseconds since the + * Unix epoch (1970-01-01 00:00:00 UTC) and returns a timestamp. + * + * ```kotlin + * // Interpret the 'microseconds' field as microseconds since epoch. + * unixMicrosToTimestamp(field("microseconds")) + * ``` + * + * @param expr The expression representing the number of microseconds since epoch. + * @return A new [Expression] representing the timestamp. + */ + +public static final com.google.firebase.firestore.pipeline.Expression unixMicrosToTimestamp(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that interprets a field's value as the number of microseconds since the + * Unix epoch (1970-01-01 00:00:00 UTC) and returns a timestamp. + * + * ```kotlin + * // Interpret the 'microseconds' field as microseconds since epoch. + * unixMicrosToTimestamp("microseconds") + * ``` + * + * @param fieldName The name of the field containing the number of microseconds since epoch. + * @return A new [Expression] representing the timestamp. + */ + +public static final com.google.firebase.firestore.pipeline.Expression unixMicrosToTimestamp(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that converts a timestamp expression to the number of microseconds + * since the Unix epoch (1970-01-01 00:00:00 UTC). + * + * ```kotlin + * // Convert the 'timestamp' field to microseconds since epoch. + * timestampToUnixMicros(field("timestamp")) + * ``` + * + * @param expr The expression representing the timestamp. + * @return A new [Expression] representing the number of microseconds since epoch. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampToUnixMicros(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that converts a timestamp field to the number of microseconds since the + * Unix epoch (1970-01-01 00:00:00 UTC). + * + * ```kotlin + * // Convert the 'timestamp' field to microseconds since epoch. + * timestampToUnixMicros("timestamp") + * ``` + * + * @param fieldName The name of the field that contains the timestamp. + * @return A new [Expression] representing the number of microseconds since epoch. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampToUnixMicros(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that interprets an expression as the number of milliseconds since the + * Unix epoch (1970-01-01 00:00:00 UTC) and returns a timestamp. + * + * ```kotlin + * // Interpret the 'milliseconds' field as milliseconds since epoch. + * unixMillisToTimestamp(field("milliseconds")) + * ``` + * + * @param expr The expression representing the number of milliseconds since epoch. + * @return A new [Expression] representing the timestamp. + */ + +public static final com.google.firebase.firestore.pipeline.Expression unixMillisToTimestamp(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that interprets a field's value as the number of milliseconds since the + * Unix epoch (1970-01-01 00:00:00 UTC) and returns a timestamp. + * + * ```kotlin + * // Interpret the 'milliseconds' field as milliseconds since epoch. + * unixMillisToTimestamp("milliseconds") + * ``` + * + * @param fieldName The name of the field containing the number of milliseconds since epoch. + * @return A new [Expression] representing the timestamp. + */ + +public static final com.google.firebase.firestore.pipeline.Expression unixMillisToTimestamp(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that converts a timestamp expression to the number of milliseconds + * since the Unix epoch (1970-01-01 00:00:00 UTC). + * + * ```kotlin + * // Convert the 'timestamp' field to milliseconds since epoch. + * timestampToUnixMillis(field("timestamp")) + * ``` + * + * @param expr The expression representing the timestamp. + * @return A new [Expression] representing the number of milliseconds since epoch. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampToUnixMillis(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that converts a timestamp field to the number of milliseconds since the + * Unix epoch (1970-01-01 00:00:00 UTC). + * + * ```kotlin + * // Convert the 'timestamp' field to milliseconds since epoch. + * timestampToUnixMillis("timestamp") + * ``` + * + * @param fieldName The name of the field that contains the timestamp. + * @return A new [Expression] representing the number of milliseconds since epoch. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampToUnixMillis(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that interprets an expression as the number of seconds since the Unix + * epoch (1970-01-01 00:00:00 UTC) and returns a timestamp. + * + * ```kotlin + * // Interpret the 'seconds' field as seconds since epoch. + * unixSecondsToTimestamp(field("seconds")) + * ``` + * + * @param expr The expression representing the number of seconds since epoch. + * @return A new [Expression] representing the timestamp. + */ + +public static final com.google.firebase.firestore.pipeline.Expression unixSecondsToTimestamp(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that interprets a field's value as the number of seconds since the Unix + * epoch (1970-01-01 00:00:00 UTC) and returns a timestamp. + * + * ```kotlin + * // Interpret the 'seconds' field as seconds since epoch. + * unixSecondsToTimestamp("seconds") + * ``` + * + * @param fieldName The name of the field containing the number of seconds since epoch. + * @return A new [Expression] representing the timestamp. + */ + +public static final com.google.firebase.firestore.pipeline.Expression unixSecondsToTimestamp(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that converts a timestamp expression to the number of seconds since the + * Unix epoch (1970-01-01 00:00:00 UTC). + * + * ```kotlin + * // Convert the 'timestamp' field to seconds since epoch. + * timestampToUnixSeconds(field("timestamp")) + * ``` + * + * @param expr The expression representing the timestamp. + * @return A new [Expression] representing the number of seconds since epoch. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampToUnixSeconds(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that converts a timestamp field to the number of seconds since the Unix + * epoch (1970-01-01 00:00:00 UTC). + * + * ```kotlin + * // Convert the 'timestamp' field to seconds since epoch. + * timestampToUnixSeconds("timestamp") + * ``` + * + * @param fieldName The name of the field that contains the timestamp. + * @return A new [Expression] representing the number of seconds since epoch. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampToUnixSeconds(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that adds a specified amount of time to a timestamp. + * + * ```kotlin + * // Add some duration determined by field 'unit' and 'amount' to the 'timestamp' field. + * timestampAdd(field("timestamp"), field("unit"), field("amount")) + * ``` + * + * @param timestamp The expression representing the timestamp. + * @param unit The expression representing the unit of time to add. Valid units include + * "microsecond", "millisecond", "second", "minute", "hour" and "day". + * @param amount The expression representing the amount of time to add. + * @return A new [Expression] representing the resulting timestamp. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampAdd(com.google.firebase.firestore.pipeline.Expression timestamp, com.google.firebase.firestore.pipeline.Expression unit, com.google.firebase.firestore.pipeline.Expression amount) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that adds a specified amount of time to a timestamp. + * + * ```kotlin + * // Add 1 day to the 'timestamp' field. + * timestampAdd(field("timestamp"), "day", 1) + * ``` + * + * @param timestamp The expression representing the timestamp. + * @param unit The unit of time to add. Valid units include "microsecond", "millisecond", + * "second", "minute", "hour" and "day". + * @param amount The amount of time to add. + * @return A new [Expression] representing the resulting timestamp. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampAdd(com.google.firebase.firestore.pipeline.Expression timestamp, java.lang.String unit, long amount) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that adds a specified amount of time to a timestamp. + * + * ```kotlin + * // Add some duration determined by field 'unit' and 'amount' to the 'timestamp' field. + * timestampAdd("timestamp", field("unit"), field("amount")) + * ``` + * + * @param fieldName The name of the field that contains the timestamp. + * @param unit The expression representing the unit of time to add. Valid units include + * "microsecond", "millisecond", "second", "minute", "hour" and "day". + * @param amount The expression representing the amount of time to add. + * @return A new [Expression] representing the resulting timestamp. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampAdd(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression unit, com.google.firebase.firestore.pipeline.Expression amount) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that adds a specified amount of time to a timestamp. + * + * ```kotlin + * // Add 1 day to the 'timestamp' field. + * timestampAdd("timestamp", "day", 1) + * ``` + * + * @param fieldName The name of the field that contains the timestamp. + * @param unit The unit of time to add. Valid units include "microsecond", "millisecond", + * "second", "minute", "hour" and "day". + * @param amount The amount of time to add. + * @return A new [Expression] representing the resulting timestamp. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampAdd(java.lang.String fieldName, java.lang.String unit, long amount) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that subtracts a specified amount of time to a timestamp. + * + * ```kotlin + * // Subtract some duration determined by field 'unit' and 'amount' from the 'timestamp' field. + * timestampSubtract(field("timestamp"), field("unit"), field("amount")) + * ``` + * + * @param timestamp The expression representing the timestamp. + * @param unit The expression representing the unit of time to subtract. Valid units include + * "microsecond", "millisecond", "second", "minute", "hour" and "day". + * @param amount The expression representing the amount of time to subtract. + * @return A new [Expression] representing the resulting timestamp. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampSubtract(com.google.firebase.firestore.pipeline.Expression timestamp, com.google.firebase.firestore.pipeline.Expression unit, com.google.firebase.firestore.pipeline.Expression amount) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that subtracts a specified amount of time to a timestamp. + * + * ```kotlin + * // Subtract 1 day from the 'timestamp' field. + * timestampSubtract(field("timestamp"), "day", 1) + * ``` + * + * @param timestamp The expression representing the timestamp. + * @param unit The unit of time to subtract. Valid units include "microsecond", "millisecond", + * "second", "minute", "hour" and "day". + * @param amount The amount of time to subtract. + * @return A new [Expression] representing the resulting timestamp. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampSubtract(com.google.firebase.firestore.pipeline.Expression timestamp, java.lang.String unit, long amount) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that subtracts a specified amount of time to a timestamp. + * + * ```kotlin + * // Subtract some duration determined by field 'unit' and 'amount' from the 'timestamp' field. + * timestampSubtract("timestamp", field("unit"), field("amount")) + * ``` + * + * @param fieldName The name of the field that contains the timestamp. + * @param unit The unit of time to subtract. Valid units include "microsecond", "millisecond", + * "second", "minute", "hour" and "day". + * @param amount The amount of time to subtract. + * @return A new [Expression] representing the resulting timestamp. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampSubtract(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression unit, com.google.firebase.firestore.pipeline.Expression amount) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that subtracts a specified amount of time to a timestamp. + * + * ```kotlin + * // Subtract 1 day from the 'timestamp' field. + * timestampSubtract("timestamp", "day", 1) + * ``` + * + * @param fieldName The name of the field that contains the timestamp. + * @param unit The unit of time to subtract. Valid units include "microsecond", "millisecond", + * "second", "minute", "hour" and "day". + * @param amount The amount of time to subtract. + * @return A new [Expression] representing the resulting timestamp. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampSubtract(java.lang.String fieldName, java.lang.String unit, long amount) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates a timestamp to a specified granularity. + * + * ```kotlin + * // Truncate the 'createdAt' timestamp to the beginning of the day. + * timestampTruncate(field("createdAt"), "day") + * ``` + * + * @param timestamp The timestamp expression. + * @param granularity The granularity to truncate to. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @return A new [Expression] representing the truncated timestamp. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampTruncate(com.google.firebase.firestore.pipeline.Expression timestamp, java.lang.String granularity) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates a timestamp to a specified granularity. + * + * ```kotlin + * // Truncate the 'createdAt' timestamp to the beginning of the day. + * timestampTruncate(field("createdAt"), field("granularity")) + * ``` + * + * @param timestamp The timestamp expression. + * @param granularity The granularity expression to truncate to. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @return A new [Expression] representing the truncated timestamp. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampTruncate(com.google.firebase.firestore.pipeline.Expression timestamp, com.google.firebase.firestore.pipeline.Expression granularity) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates a timestamp to a specified granularity. + * + * ```kotlin + * // Truncate the 'createdAt' timestamp to the beginning of the day. + * timestampTruncate("createdAt", "day") + * ``` + * + * @param fieldName The name of the field containing the timestamp. + * @param granularity The granularity to truncate to. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @return A new [Expression] representing the truncated timestamp. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampTruncate(java.lang.String fieldName, java.lang.String granularity) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates a timestamp to a specified granularity. + * + * ```kotlin + * // Truncate the 'createdAt' timestamp to the beginning of the day. + * timestampTruncate("createdAt", field("granularity")) + * ``` + * + * @param fieldName The name of the field containing the timestamp. + * @param granularity The granularity expression to truncate to. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @return A new [Expression] representing the truncated timestamp. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampTruncate(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression granularity) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates a timestamp to a specified granularity in a given + * timezone. + * + * ```kotlin + * // Truncate the 'createdAt' timestamp to the beginning of the day in "America/Los_Angeles" + * // timezone. + * timestampTruncateWithTimezone(field("createdAt"), "day", "America/Los_Angeles") + * ``` + * + * @param timestamp The timestamp expression. + * @param granularity The granularity to truncate to. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone to use for truncation. Valid values are from the TZ database + * (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". + * @return A new [Expression] representing the truncated timestamp. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(com.google.firebase.firestore.pipeline.Expression timestamp, java.lang.String granularity, java.lang.String timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates a timestamp to a specified granularity in a given + * timezone. + * + * ```kotlin + * // Truncate the 'createdAt' timestamp to the beginning of the day in "America/Los_Angeles" + * // timezone. + * timestampTruncateWithTimezone(field("createdAt"), field("granularity"), "America/Los_Angeles") + * ``` + * + * @param timestamp The timestamp expression. + * @param granularity The granularity expression to truncate to. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone to use for truncation. Valid values are from the TZ database + * (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". + * @return A new [Expression] representing the truncated timestamp. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(com.google.firebase.firestore.pipeline.Expression timestamp, com.google.firebase.firestore.pipeline.Expression granularity, java.lang.String timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates a timestamp to a specified granularity in a given + * timezone. + * + * ```kotlin + * // Truncate the 'createdAt' timestamp to the beginning of the day in "America/Los_Angeles" + * // timezone. + * timestampTruncateWithTimezone("createdAt", "day", "America/Los_Angeles") + * ``` + * + * @param fieldName The name of the field containing the timestamp. + * @param granularity The granularity to truncate to. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone to use for truncation. Valid values are from the TZ database + * (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". + * @return A new [Expression] representing the truncated timestamp. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(java.lang.String fieldName, java.lang.String granularity, java.lang.String timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates a timestamp to a specified granularity in a given + * timezone. + * + * ```kotlin + * // Truncate the 'createdAt' timestamp to the beginning of the day in "America/Los_Angeles" + * // timezone. + * timestampTruncateWithTimezone("createdAt", field("granularity"), "America/Los_Angeles") + * ``` + * + * @param fieldName The name of the field containing the timestamp. + * @param granularity The granularity expression to truncate to. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone to use for truncation. Valid values are from the TZ database + * (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". + * @return A new [Expression] representing the truncated timestamp. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression granularity, java.lang.String timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates a timestamp to a specified granularity in a given + * timezone. + * + * ```kotlin + * // Truncate the 'createdAt' timestamp to the beginning of the day in timezone specified by + * // the 'tz' field. + * timestampTruncateWithTimezone(field("createdAt"), "day", field("tz")) + * ``` + * + * @param timestamp The timestamp expression. + * @param granularity The granularity to truncate to. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone expression to use for truncation. Valid values are from the TZ + * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". + * @return A new [Expression] representing the truncated timestamp. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(com.google.firebase.firestore.pipeline.Expression timestamp, java.lang.String granularity, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates a timestamp to a specified granularity in a given + * timezone. + * + * ```kotlin + * // Truncate the 'createdAt' timestamp to the beginning of the day in timezone specified by + * // the 'tz' field. + * timestampTruncateWithTimezone(field("createdAt"), field("granularity"), field("tz")) + * ``` + * + * @param timestamp The timestamp expression. + * @param granularity The granularity expression to truncate to. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone expression to use for truncation. Valid values are from the TZ + * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". + * @return A new [Expression] representing the truncated timestamp. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(com.google.firebase.firestore.pipeline.Expression timestamp, com.google.firebase.firestore.pipeline.Expression granularity, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates a timestamp to a specified granularity in a given + * timezone. + * + * ```kotlin + * // Truncate the 'createdAt' timestamp to the beginning of the day in timezone specified by + * // the 'tz' field. + * timestampTruncateWithTimezone("createdAt", "day", field("tz")) + * ``` + * + * @param fieldName The name of the field containing the timestamp. + * @param granularity The granularity to truncate to. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone expression to use for truncation. Valid values are from the TZ + * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". + * @return A new [Expression] representing the truncated timestamp. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(java.lang.String fieldName, java.lang.String granularity, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates a timestamp to a specified granularity in a given + * timezone. + * + * ```kotlin + * // Truncate the 'createdAt' timestamp to the beginning of the day in timezone specified by + * // the 'tz' field. + * timestampTruncateWithTimezone("createdAt", field("granularity"), field("tz")) + * ``` + * + * @param fieldName The name of the field containing the timestamp. + * @param granularity The granularity expression to truncate to. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone expression to use for truncation. Valid values are from the TZ + * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". + * @return A new [Expression] representing the truncated timestamp. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression granularity, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the difference between two timestamps. + * + * ```kotlin + * // Calculate the difference between the fields 'endAt' and the field 'startAt' in unit specified by + * // the 'unit' field. + * timestampDiff(field("endAt"), field("startAt"), field("unit")) + * ``` + * + * @param end The ending timestamp expression. + * @param start The starting timestamp expression. + * @param unit The unit of time for the difference. Valid values include "microsecond", + * "millisecond", "second", "minute", "hour" and "day". + * @return A new [Expression] representing the difference. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampDiff(com.google.firebase.firestore.pipeline.Expression end, com.google.firebase.firestore.pipeline.Expression start, com.google.firebase.firestore.pipeline.Expression unit) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the difference between two timestamps. + * + * ```kotlin + * // Calculate the difference in days between 'endAt' field and 'startAt' field. + * timestampDiff(field("endAt"), field("startAt"), "day") + * ``` + * + * @param end The ending timestamp expression. + * @param start The starting timestamp expression. + * @param unit The unit of time for the difference. Valid values include "microsecond", + * "millisecond", "second", "minute", "hour" and "day". + * @return A new [Expression] representing the difference. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampDiff(com.google.firebase.firestore.pipeline.Expression end, com.google.firebase.firestore.pipeline.Expression start, java.lang.String unit) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the difference between two timestamps. + * + * ```kotlin + * // Calculate the difference in days between 'endAt' and 'startAt'. + * timestampDiff("endAt", "startAt", "day") + * ``` + * + * @param endFieldName The ending timestamp field name. + * @param startFieldName The starting timestamp field name. + * @param unit The unit of time for the difference. Valid values include "microsecond", + * "millisecond", "second", "minute", "hour" and "day". + * @return A new [Expression] representing the difference. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampDiff(java.lang.String endFieldName, java.lang.String startFieldName, java.lang.String unit) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the difference between two timestamps. + * + * ```kotlin + * // Calculate the difference in days between 'endAt' and 'startAt'. + * timestampDiff("endAt", field("startAt"), "day") + * ``` + * + * @param endFieldName The ending timestamp field name. + * @param start The starting timestamp expression. + * @param unit The unit of time for the difference. Valid values include "microsecond", + * "millisecond", "second", "minute", "hour" and "day". + * @return A new [Expression] representing the difference. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampDiff(java.lang.String endFieldName, com.google.firebase.firestore.pipeline.Expression start, java.lang.String unit) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the difference between two timestamps. + * + * ```kotlin + * // Calculate the difference in days between 'endAt' and 'startAt'. + * timestampDiff(field("endAt"), "startAt", "day") + * ``` + * + * @param end The ending timestamp expression. + * @param startFieldName The starting timestamp field name. + * @param unit The unit of time for the difference. Valid values include "microsecond", + * "millisecond", "second", "minute", "hour" and "day". + * @return A new [Expression] representing the difference. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampDiff(com.google.firebase.firestore.pipeline.Expression end, java.lang.String startFieldName, java.lang.String unit) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that extracts a specified part from a timestamp. + * + * ```kotlin + * // Extract the part specified by the field 'part' from 'createdAt'. + * timestampExtract(field("createdAt"), field("part")) + * ``` + * + * @param timestamp The timestamp expression. + * @param part The part to extract from the timestamp. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", + * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", + * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". + * @return A new [Expression] representing the extracted part. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampExtract(com.google.firebase.firestore.pipeline.Expression timestamp, com.google.firebase.firestore.pipeline.Expression part) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that extracts a specified part from a timestamp. + * + * ```kotlin + * // Extract the day from the timestamp returned by the expression. + * timestampExtract(field("createdAt"), "day") + * ``` + * + * @param timestamp The timestamp expression. + * @param part The part to extract from the timestamp. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", + * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", + * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". + * @return A new [Expression] representing the extracted part. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampExtract(com.google.firebase.firestore.pipeline.Expression timestamp, java.lang.String part) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that extracts a specified part from a timestamp. + * + * ```kotlin + * // Extract the part specified by the field 'part' from 'createdAt'. + * timestampExtract("createdAt", field("part")) + * ``` + * + * @param fieldName The name of the field containing the timestamp. + * @param part The part to extract from the timestamp. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", + * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", + * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". + * @return A new [Expression] representing the extracted part. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampExtract(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression part) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that extracts a specified part from a timestamp. + * + * ```kotlin + * // Extract the day from the timestamp in the 'createdAt' field. + * timestampExtract("createdAt", "day") + * ``` + * + * @param fieldName The name of the field containing the timestamp. + * @param part The part to extract from the timestamp. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", + * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", + * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". + * @return A new [Expression] representing the extracted part. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampExtract(java.lang.String fieldName, java.lang.String part) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that extracts a specified part from a timestamp in a given timezone. + * + * ```kotlin + * // Extract the part specified by the field 'part' from 'createdAt' in the timezone specified by + * // the field 'tz'. + * timestampExtractWithTimezone(field("createdAt"), field("part"), field("tz")) + * ``` + * + * @param timestamp The timestamp expression. + * @param part The part to extract from the timestamp. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", + * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", + * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone expression to use for extraction.Valid values are from the TZ + * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not + * specified. + * @return A new [Expression] representing the extracted part. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(com.google.firebase.firestore.pipeline.Expression timestamp, com.google.firebase.firestore.pipeline.Expression part, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that extracts a specified part from a timestamp in a given timezone. + * + * ```kotlin + * // Extract the part specified by the field 'part' from 'createdAt' in the timezone "America/Los_Angeles". + * timestampExtractWithTimezone(field("createdAt"), field("part"), "America/Los_Angeles") + * ``` + * + * @param timestamp The timestamp expression. + * @param part The part to extract from the timestamp. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", + * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", + * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone expression to use for extraction.Valid values are from the TZ + * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not + * specified. + * @return A new [Expression] representing the extracted part. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(com.google.firebase.firestore.pipeline.Expression timestamp, com.google.firebase.firestore.pipeline.Expression part, java.lang.String timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that extracts a specified part from a timestamp in a given timezone. + * + * ```kotlin + * // Extract the day from the timestamp in the 'createdAt' field in the timezone "America/Los_Angeles". + * timestampExtractWithTimezone(field("createdAt"), "day", "America/Los_Angeles") + * ``` + * + * @param timestamp The timestamp expression. + * @param part The part to extract from the timestamp. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", + * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", + * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone expression to use for extraction.Valid values are from the TZ + * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not + * specified. + * @return A new [Expression] representing the extracted part. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(com.google.firebase.firestore.pipeline.Expression timestamp, java.lang.String part, java.lang.String timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that extracts a specified part from a timestamp in a given timezone. + * + * ```kotlin + * // Extract the part specified by the field 'part' from 'createdAt' in the timezone "America/Los_Angeles". + * timestampExtractWithTimezone("createdAt", field("part"), "America/Los_Angeles") + * ``` + * + * @param fieldName The name of the field containing the timestamp. + * @param part The part to extract from the timestamp. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", + * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", + * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone expression to use for extraction.Valid values are from the TZ + * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not + * specified. + * @return A new [Expression] representing the extracted part. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression part, java.lang.String timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that extracts a specified part from a timestamp in a given timezone. + * + * ```kotlin + * // Extract the day from the timestamp in the 'createdAt' field in the timezone "America/Los_Angeles". + * timestampExtractWithTimezone("createdAt", "day", "America/Los_Angeles") + * ``` + * + * @param fieldName The name of the field containing the timestamp. + * @param part The part to extract from the timestamp. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", + * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", + * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone expression to use for extraction.Valid values are from the TZ + * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not + * specified. + * @return A new [Expression] representing the extracted part. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(java.lang.String fieldName, java.lang.String part, java.lang.String timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that extracts a specified part from a timestamp in a given timezone. + * + * ```kotlin + * // Extract the day from the timestamp in the 'createdAt' field in the timezone specified by the 'tz' field. + * timestampExtractWithTimezone(field("createdAt"), "day", field("tz")) + * ``` + * + * @param timestamp The timestamp expression. + * @param part The part to extract from the timestamp. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", + * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", + * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone expression to use for extraction.Valid values are from the TZ + * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not + * specified. + * @return A new [Expression] representing the extracted part. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(com.google.firebase.firestore.pipeline.Expression timestamp, java.lang.String part, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that extracts a specified part from a timestamp in a given timezone. + * + * ```kotlin + * // Extract the part specified by the field 'part' from 'createdAt' in the timezone specified by the 'tz' field. + * timestampExtractWithTimezone("createdAt", field("part"), field("tz")) + * ``` + * + * @param fieldName The name of the field containing the timestamp. + * @param part The part to extract from the timestamp. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", + * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", + * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone expression to use for extraction.Valid values are from the TZ + * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not + * specified. + * @return A new [Expression] representing the extracted part. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression part, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that extracts a specified part from a timestamp in a given timezone. + * + * ```kotlin + * // Extract the day from the timestamp in the 'createdAt' field in the timezone specified by the 'tz' field. + * timestampExtractWithTimezone("createdAt", "day", field("tz")) + * ``` + * + * @param fieldName The name of the field containing the timestamp. + * @param part The part to extract from the timestamp. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", + * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", + * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone expression to use for extraction.Valid values are from the TZ + * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not + * specified. + * @return A new [Expression] representing the extracted part. + */ + +public static final com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(java.lang.String fieldName, java.lang.String part, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if two expressions are equal. + * + * ```kotlin + * // Check if the 'age' field is equal to an expression + * equal(field("age"), field("minAge").add(10)) + * ``` + * + * @param left The first expression to compare. + * @param right The second expression to compare to. + * @return A new [BooleanExpression] representing the equality comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression equal(com.google.firebase.firestore.pipeline.Expression left, com.google.firebase.firestore.pipeline.Expression right) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if an expression is equal to a value. + * + * ```kotlin + * // Check if the 'age' field is equal to 21 + * equal(field("age"), 21) + * ``` + * + * @param left The first expression to compare. + * @param right The value to compare to. + * @return A new [BooleanExpression] representing the equality comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression equal(com.google.firebase.firestore.pipeline.Expression left, java.lang.Object right) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field's value is equal to an expression. + * + * ```kotlin + * // Check if the 'age' field is equal to the 'limit' field + * equal("age", field("limit")) + * ``` + * + * @param fieldName The field name to compare. + * @param expression The expression to compare to. + * @return A new [BooleanExpression] representing the equality comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression equal(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field's value is equal to another value. + * + * ```kotlin + * // Check if the 'city' field is equal to string constant "London" + * equal("city", "London") + * ``` + * + * @param fieldName The field name to compare. + * @param value The value to compare to. + * @return A new [BooleanExpression] representing the equality comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression equal(java.lang.String fieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if two expressions are not equal. + * + * ```kotlin + * // Check if the 'status' field is not equal to the value of the 'otherStatus' field + * notEqual(field("status"), field("otherStatus")) + * ``` + * + * @param left The first expression to compare. + * @param right The second expression to compare to. + * @return A new [BooleanExpression] representing the inequality comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression notEqual(com.google.firebase.firestore.pipeline.Expression left, com.google.firebase.firestore.pipeline.Expression right) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if an expression is not equal to a value. + * + * ```kotlin + * // Check if the 'status' field is not equal to "completed" + * notEqual(field("status"), "completed") + * ``` + * + * @param left The first expression to compare. + * @param right The value to compare to. + * @return A new [BooleanExpression] representing the inequality comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression notEqual(com.google.firebase.firestore.pipeline.Expression left, java.lang.Object right) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field's value is not equal to an expression. + * + * ```kotlin + * // Check if the 'status' field is not equal to the value of the 'otherStatus' field + * notEqual("status", field("otherStatus")) + * ``` + * + * @param fieldName The field name to compare. + * @param expression The expression to compare to. + * @return A new [BooleanExpression] representing the inequality comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression notEqual(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field's value is not equal to another value. + * + * ```kotlin + * // Check if the 'status' field is not equal to "completed" + * notEqual("status", "completed") + * + * // Check if the 'country' field is not equal to "USA" + * notEqual("country", "USA") + * ``` + * + * @param fieldName The field name to compare. + * @param value The value to compare to. + * @return A new [BooleanExpression] representing the inequality comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression notEqual(java.lang.String fieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if the first expression is greater than the second + * expression. + * + * ```kotlin + * // Check if the 'age' field is greater than the 'limit' field + * greaterThan(field("age"), field("limit")) + * ``` + * + * @param left The first expression to compare. + * @param right The second expression to compare to. + * @return A new [BooleanExpression] representing the greater than comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression greaterThan(com.google.firebase.firestore.pipeline.Expression left, com.google.firebase.firestore.pipeline.Expression right) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if an expression is greater than a value. + * + * ```kotlin + * // Check if the 'price' field is greater than 100 + * greaterThan(field("price"), 100) + * ``` + * + * @param left The first expression to compare. + * @param right The value to compare to. + * @return A new [BooleanExpression] representing the greater than comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression greaterThan(com.google.firebase.firestore.pipeline.Expression left, java.lang.Object right) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field's value is greater than an expression. + * + * ```kotlin + * // Check if the 'age' field is greater than the 'limit' field + * greaterThan("age", field("limit")) + * ``` + * + * @param fieldName The field name to compare. + * @param expression The expression to compare to. + * @return A new [BooleanExpression] representing the greater than comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression greaterThan(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field's value is greater than another value. + * + * ```kotlin + * // Check if the 'price' field is greater than 100 + * greaterThan("price", 100) + * ``` + * + * @param fieldName The field name to compare. + * @param value The value to compare to. + * @return A new [BooleanExpression] representing the greater than comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression greaterThan(java.lang.String fieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if the first expression is greater than or equal to the + * second expression. + * + * ```kotlin + * // Check if the 'quantity' field is greater than or equal to field 'requirement' plus 1 + * greaterThanOrEqual(field("quantity"), field("requirement").add(1)) + * ``` + * + * @param left The first expression to compare. + * @param right The second expression to compare to. + * @return A new [BooleanExpression] representing the greater than or equal to comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression greaterThanOrEqual(com.google.firebase.firestore.pipeline.Expression left, com.google.firebase.firestore.pipeline.Expression right) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if an expression is greater than or equal to a value. + * + * ```kotlin + * // Check if the 'score' field is greater than or equal to 80 + * greaterThanOrEqual(field("score"), 80) + * ``` + * + * @param left The first expression to compare. + * @param right The value to compare to. + * @return A new [BooleanExpression] representing the greater than or equal to comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression greaterThanOrEqual(com.google.firebase.firestore.pipeline.Expression left, java.lang.Object right) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field's value is greater than or equal to an + * expression. + * + * ```kotlin + * // Check if the 'quantity' field is greater than or equal to field 'requirement' plus 1 + * greaterThanOrEqual("quantity", field("requirement").add(1)) + * ``` + * + * @param fieldName The field name to compare. + * @param expression The expression to compare to. + * @return A new [BooleanExpression] representing the greater than or equal to comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression greaterThanOrEqual(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field's value is greater than or equal to another + * value. + * + * ```kotlin + * // Check if the 'score' field is greater than or equal to 80 + * greaterThanOrEqual("score", 80) + * ``` + * + * @param fieldName The field name to compare. + * @param value The value to compare to. + * @return A new [BooleanExpression] representing the greater than or equal to comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression greaterThanOrEqual(java.lang.String fieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if the first expression is less than the second expression. + * + * ```kotlin + * // Check if the 'age' field is less than 'limit' + * lessThan(field("age"), field("limit")) + * ``` + * + * @param left The first expression to compare. + * @param right The second expression to compare to. + * @return A new [BooleanExpression] representing the less than comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression lessThan(com.google.firebase.firestore.pipeline.Expression left, com.google.firebase.firestore.pipeline.Expression right) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if an expression is less than a value. + * + * ```kotlin + * // Check if the 'price' field is less than 50 + * lessThan(field("price"), 50) + * ``` + * + * @param left The first expression to compare. + * @param right The value to compare to. + * @return A new [BooleanExpression] representing the less than comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression lessThan(com.google.firebase.firestore.pipeline.Expression left, java.lang.Object right) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field's value is less than an expression. + * + * ```kotlin + * // Check if the 'age' field is less than 'limit' + * lessThan("age", field("limit")) + * ``` + * + * @param fieldName The field name to compare. + * @param expression The expression to compare to. + * @return A new [BooleanExpression] representing the less than comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression lessThan(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field's value is less than another value. + * + * ```kotlin + * // Check if the 'price' field is less than 50 + * lessThan("price", 50) + * ``` + * + * @param fieldName The field name to compare. + * @param value The value to compare to. + * @return A new [BooleanExpression] representing the less than comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression lessThan(java.lang.String fieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if the first expression is less than or equal to the second + * expression. + * + * ```kotlin + * // Check if the 'quantity' field is less than or equal to 20 + * lessThanOrEqual(field("quantity"), constant(20)) + * ``` + * + * @param left The first expression to compare. + * @param right The second expression to compare to. + * @return A new [BooleanExpression] representing the less than or equal to comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression lessThanOrEqual(com.google.firebase.firestore.pipeline.Expression left, com.google.firebase.firestore.pipeline.Expression right) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if an expression is less than or equal to a value. + * + * ```kotlin + * // Check if the 'score' field is less than or equal to 70 + * lessThanOrEqual(field("score"), 70) + * ``` + * + * @param left The first expression to compare. + * @param right The value to compare to. + * @return A new [BooleanExpression] representing the less than or equal to comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression lessThanOrEqual(com.google.firebase.firestore.pipeline.Expression left, java.lang.Object right) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field's value is less than or equal to an expression. + * + * ```kotlin + * // Check if the 'quantity' field is less than or equal to 20 + * lessThanOrEqual("quantity", constant(20)) + * ``` + * + * @param fieldName The field name to compare. + * @param expression The expression to compare to. + * @return A new [BooleanExpression] representing the less than or equal to comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression lessThanOrEqual(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field's value is less than or equal to another value. + * + * ```kotlin + * // Check if the 'score' field is less than or equal to 70 + * lessThanOrEqual("score", 70) + * ``` + * + * @param fieldName The field name to compare. + * @param value The value to compare to. + * @return A new [BooleanExpression] representing the less than or equal to comparison. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression lessThanOrEqual(java.lang.String fieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that concatenates strings, arrays, or blobs. Types cannot be mixed. + * + * ```kotlin + * // Concatenate the 'firstName' and 'lastName' fields with a space in between. + * concat(field("firstName"), " ", field("lastName")) + * ``` + * + * @param first The first expression to concatenate. + * @param second The second expression to concatenate. + * @param others Additional expressions to concatenate. + * @return A new [Expression] representing the concatenation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression concat(com.google.firebase.firestore.pipeline.Expression first, com.google.firebase.firestore.pipeline.Expression second, java.lang.Object... others) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that concatenates strings, arrays, or blobs. Types cannot be mixed. + * + * ```kotlin + * // Concatenate a field with a literal string. + * concat(field("firstName"), "Doe") + * ``` + * + * @param first The first expression to concatenate. + * @param second The second value to concatenate. + * @param others Additional values to concatenate. + * @return A new [Expression] representing the concatenation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression concat(com.google.firebase.firestore.pipeline.Expression first, java.lang.Object second, java.lang.Object... others) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that concatenates strings, arrays, or blobs. Types cannot be mixed. + * + * ```kotlin + * // Concatenate a field name with an expression. + * concat("firstName", field("lastName")) + * ``` + * + * @param first The name of the field containing the first value to concatenate. + * @param second The second expression to concatenate. + * @param others Additional expressions to concatenate. + * @return A new [Expression] representing the concatenation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression concat(java.lang.String first, com.google.firebase.firestore.pipeline.Expression second, java.lang.Object... others) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that concatenates strings, arrays, or blobs. Types cannot be mixed. + * + * ```kotlin + * // Concatenate a field name with a literal string. + * concat("firstName", "Doe") + * ``` + * + * @param first The name of the field containing the first value to concatenate. + * @param second The second value to concatenate. + * @param others Additional values to concatenate. + * @return A new [Expression] representing the concatenation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression concat(java.lang.String first, java.lang.Object second, java.lang.Object... others) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that creates a Firestore array value from an input array. + * + * ```kotlin + * // Create an array of numbers + * array(1, 2, 3) + * + * // Create an array containing a field value and a constant + * array(field("quantity"), 10) + * ``` + * + * @param elements The input array to evaluate in the expression. + * @return A new [Expression] representing the array function. + */ + +public static final com.google.firebase.firestore.pipeline.Expression array(java.lang.Object... elements) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that creates a Firestore array value from an input array. + * + * @param elements The input array to evaluate in the expression. + * @return A new [Expression] representing the array function. + */ + +public static final com.google.firebase.firestore.pipeline.Expression array(java.util.List elements) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that concatenates an array with other arrays. + * + * ```kotlin + * // Combine the 'items' array with another array field. + * arrayConcat(field("items"), field("otherItems")) + * ``` + * + * @param firstArray The first array expression to concatenate to. + * @param secondArray An expression that evaluates to array to concatenate. + * @param otherArrays Optional additional array expressions or array literals to concatenate. + * @return A new [Expression] representing the arrayConcat operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayConcat(com.google.firebase.firestore.pipeline.Expression firstArray, com.google.firebase.firestore.pipeline.Expression secondArray, java.lang.Object... otherArrays) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that concatenates an array with other arrays. + * + * ```kotlin + * // Combine the 'items' array with another array field. + * arrayConcat(field("items"), field("otherItems")) + * ``` + * + * @param firstArray The first array expression to concatenate to. + * @param secondArray An array expression or array literal to concatenate. + * @param otherArrays Optional additional array expressions or array literals to concatenate. + * @return A new [Expression] representing the arrayConcat operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayConcat(com.google.firebase.firestore.pipeline.Expression firstArray, java.lang.Object secondArray, java.lang.Object... otherArrays) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that concatenates a field's array value with other arrays. + * + * ```kotlin + * // Combine the 'items' array with another array field. + * arrayConcat("items", field("otherItems")) + * ``` + * + * @param firstArrayField The name of field that contains first array to concatenate to. + * @param secondArray An expression that evaluates to array to concatenate. + * @param otherArrays Optional additional array expressions or array literals to concatenate. + * @return A new [Expression] representing the arrayConcat operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayConcat(java.lang.String firstArrayField, com.google.firebase.firestore.pipeline.Expression secondArray, java.lang.Object... otherArrays) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that concatenates a field's array value with other arrays. + * + * ```kotlin + * // Combine the 'items' array with a literal array. + * arrayConcat("items", listOf("a", "b")) + * ``` + * + * @param firstArrayField The name of field that contains first array to concatenate to. + * @param secondArray An array expression or array literal to concatenate. + * @param otherArrays Optional additional array expressions or array literals to concatenate. + * @return A new [Expression] representing the arrayConcat operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayConcat(java.lang.String firstArrayField, java.lang.Object secondArray, java.lang.Object... otherArrays) { throw new RuntimeException("Stub!"); } + +/** + * Reverses the order of elements in the [array]. + * + * ```kotlin + * // Reverse the value of the 'myArray' field. + * arrayReverse(field("myArray")) + * ``` + * + * @param array The array expression to reverse. + * @return A new [Expression] representing the arrayReverse operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayReverse(com.google.firebase.firestore.pipeline.Expression array) { throw new RuntimeException("Stub!"); } + +/** + * Reverses the order of elements in the array field. + * + * ```kotlin + * // Reverse the value of the 'myArray' field. + * arrayReverse("myArray") + * ``` + * + * @param arrayFieldName The name of field that contains the array to reverse. + * @return A new [Expression] representing the arrayReverse operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayReverse(java.lang.String arrayFieldName) { throw new RuntimeException("Stub!"); } + +/** + * Filters an [array] expression based on a predicate. + * + * ```kotlin + * // Filter 'scores' array to include only values greater than 50 + * arrayFilter(field("scores"), "score", greaterThan(variable("score"), 50)) + * ``` + * + * @param array The array expression to filter. + * @param alias The alias to use for the current element in the filter expression. + * @param filter The predicate boolean expression used to filter the elements. + * @return A new [Expression] representing the arrayFilter operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayFilter(com.google.firebase.firestore.pipeline.Expression array, java.lang.String alias, com.google.firebase.firestore.pipeline.BooleanExpression filter) { throw new RuntimeException("Stub!"); } + +/** + * Filters an array field based on a predicate. + * + * ```kotlin + * // Filter 'scores' array to include only values greater than 50 + * arrayFilter("scores", "score", greaterThan(variable("score"), 50)) + * ``` + * + * @param arrayFieldName The name of field that contains array to filter. + * @param alias The alias to use for the current element in the filter expression. + * @param filter The predicate boolean expression used to filter the elements. + * @return A new [Expression] representing the arrayFilter operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayFilter(java.lang.String arrayFieldName, java.lang.String alias, com.google.firebase.firestore.pipeline.BooleanExpression filter) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a provided transformation to each element in an array. + * + * ```kotlin + * // Transform 'scores' array by multiplying each score by 10 + * arrayTransform(field("scores"), "score", multiply(variable("score"), 10)) + * ``` + * + * @param array The array expression to transform. + * @param elementAlias The alias to use for the current element in the transform expression. + * @param transform The expression used to transform the elements. + * @return A new [Expression] representing the arrayTransform operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayTransform(com.google.firebase.firestore.pipeline.Expression array, java.lang.String elementAlias, com.google.firebase.firestore.pipeline.Expression transform) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a provided transformation to each element in an array. + * + * ```kotlin + * // Transform 'scores' array by multiplying each score by 10 + * arrayTransform("scores", "score", multiply(variable("score"), 10)) + * ``` + * + * @param arrayFieldName The name of field that contains array to transform. + * @param elementAlias The alias to use for the current element in the transform expression. + * @param transform The expression used to transform the elements. + * @return A new [Expression] representing the arrayTransform operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayTransform(java.lang.String arrayFieldName, java.lang.String elementAlias, com.google.firebase.firestore.pipeline.Expression transform) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a provided transformation to each element in an array, + * providing the element's index to the transformation expression. + * + * ```kotlin + * // Transform 'scores' array by adding the index + * arrayTransformWithIndex(field("scores"), "score", "i", add(variable("score"), variable("i"))) + * ``` + * + * @param array The array expression to transform. + * @param elementAlias The alias to use for the current element in the transform expression. + * @param indexAlias The alias to use for the current index. + * @param transform The expression used to transform the elements. + * @return A new [Expression] representing the arrayTransformWithIndex operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayTransformWithIndex(com.google.firebase.firestore.pipeline.Expression array, java.lang.String elementAlias, java.lang.String indexAlias, com.google.firebase.firestore.pipeline.Expression transform) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a provided transformation to each element in an array, + * providing the element's index to the transformation expression. + * + * ```kotlin + * // Transform 'scores' array by adding the index + * arrayTransformWithIndex("scores", "score", "i", add(variable("score"), variable("i"))) + * ``` + * + * @param arrayFieldName The name of field that contains array to transform. + * @param elementAlias The alias to use for the current element in the transform expression. + * @param indexAlias The alias to use for the current index. + * @param transform The expression used to transform the elements. + * @return A new [Expression] representing the arrayTransformWithIndex operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayTransformWithIndex(java.lang.String arrayFieldName, java.lang.String elementAlias, java.lang.String indexAlias, com.google.firebase.firestore.pipeline.Expression transform) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a slice of an [array] expression to its end. + * + * ```kotlin + * // Get elements from the 'items' array starting from index 2 + * arraySliceToEnd(field("items"), 2) + * ``` + * + * @param array The array expression. + * @param offset The starting index. + * @return A new [Expression] representing the arraySliceToEnd operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arraySliceToEnd(com.google.firebase.firestore.pipeline.Expression array, int offset) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a slice of an [array] expression to its end. + * + * ```kotlin + * // Get elements from the 'items' array starting at an offset defined by a field + * arraySliceToEnd(field("items"), field("startIdx")) + * ``` + * + * @param array The array expression. + * @param offset The starting index. + * @return A new [Expression] representing the arraySliceToEnd operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arraySliceToEnd(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression offset) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a slice of an array field to its end. + * + * ```kotlin + * // Get elements from the 'items' array starting from index 2 + * arraySliceToEnd("items", 2) + * ``` + * + * @param arrayFieldName The name of field that contains the array. + * @param offset The starting index. + * @return A new [Expression] representing the arraySliceToEnd operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arraySliceToEnd(java.lang.String arrayFieldName, int offset) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a slice of an array field to its end. + * + * ```kotlin + * // Get elements from the 'items' array starting at an offset defined by a field + * arraySliceToEnd("items", field("startIdx")) + * ``` + * + * @param arrayFieldName The name of field that contains the array. + * @param offset The starting index. + * @return A new [Expression] representing the arraySliceToEnd operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arraySliceToEnd(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression offset) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a slice of an [array] expression. + * + * ```kotlin + * // Get 5 elements from the 'items' array starting from index 2 + * arraySlice(field("items"), 2, 5) + * ``` + * + * @param array The array expression. + * @param offset The starting index. + * @param length The number of elements to return. + * @return A new [Expression] representing the arraySlice operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arraySlice(com.google.firebase.firestore.pipeline.Expression array, int offset, int length) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a slice of an array field. + * + * ```kotlin + * // Get 5 elements from the 'items' array starting from index 2 + * arraySlice("items", 2, 5) + * ``` + * + * @param arrayFieldName The name of field that contains the array. + * @param offset The starting index. + * @param length The number of elements to return. + * @return A new [Expression] representing the arraySlice operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arraySlice(java.lang.String arrayFieldName, int offset, int length) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a slice of an [array] expression. + * + * ```kotlin + * // Get elements from the 'items' array using expressions for offset and length + * arraySlice(field("items"), field("startIdx"), field("length")) + * ``` + * + * @param array The array expression. + * @param offset The starting index. + * @param length The number of elements to return. + * @return A new [Expression] representing the arraySlice operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arraySlice(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression offset, com.google.firebase.firestore.pipeline.Expression length) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a slice of an array field. + * + * ```kotlin + * // Get elements from the 'items' array using expressions for offset and length + * arraySlice("items", field("startIdx"), field("length")) + * ``` + * + * @param arrayFieldName The name of field that contains the array. + * @param offset The starting index. + * @param length The number of elements to return. + * @return A new [Expression] representing the arraySlice operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arraySlice(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression offset, com.google.firebase.firestore.pipeline.Expression length) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the sum of the elements in an array. + * + * ```kotlin + * // Get the sum of elements in the 'scores' array. + * arraySum(field("scores")) + * ``` + * + * @param array The array expression to sum. + * @return A new [Expression] representing the sum of the array elements. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arraySum(com.google.firebase.firestore.pipeline.Expression array) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the sum of the elements in an array field. + * + * ```kotlin + * // Get the sum of elements in the 'scores' array. + * arraySum("scores") + * ``` + * + * @param arrayFieldName The name of the field containing the array to sum. + * @return A new [Expression] representing the sum of the array elements. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arraySum(java.lang.String arrayFieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if the array contains a specific [element]. + * + * @param array The array expression to check. + * @param element The element to search for in the array. + * @return A new [BooleanExpression] representing the arrayContains operation. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression arrayContains(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression element) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if the array field contains a specific [element]. + * + * ```kotlin + * // Check if the 'sizes' array contains the value from the 'selectedSize' field + * arrayContains("sizes", field("selectedSize")) + * ``` + * + * @param arrayFieldName The name of field that contains array to check. + * @param element The element to search for in the array. + * @return A new [BooleanExpression] representing the arrayContains operation. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression arrayContains(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression element) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if the [array] contains a specific [element]. + * + * ```kotlin + * // Check if the 'sizes' array contains the value from the 'selectedSize' field + * arrayContains(field("sizes"), field("selectedSize")) + * + * // Check if the 'colors' array contains "red" + * arrayContains(field("colors"), "red") + * ``` + * + * @param array The array expression to check. + * @param element The element to search for in the array. + * @return A new [BooleanExpression] representing the arrayContains operation. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression arrayContains(com.google.firebase.firestore.pipeline.Expression array, java.lang.Object element) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if the array field contains a specific [element]. + * + * ```kotlin + * // Check if the 'colors' array contains "red" + * arrayContains("colors", "red") + * ``` + * + * @param arrayFieldName The name of field that contains array to check. + * @param element The element to search for in the array. + * @return A new [BooleanExpression] representing the arrayContains operation. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression arrayContains(java.lang.String arrayFieldName, java.lang.Object element) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if [array] contains all the specified [values]. + * + * ```kotlin + * // Check if the 'tags' array contains both the value in field "tag1" and the literal value "tag2" + * arrayContainsAll(field("tags"), listOf(field("tag1"), "tag2")) + * ``` + * + * @param array The array expression to check. + * @param values The elements to check for in the array. + * @return A new [BooleanExpression] representing the arrayContainsAll operation. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAll(com.google.firebase.firestore.pipeline.Expression array, java.util.List values) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if [array] contains all elements of [arrayExpression]. + * + * ```kotlin + * // Check if the 'tags' array contains both of the values from field "tag1" and the literal value "tag2" + * arrayContainsAll(field("tags"), array(field("tag1"), "tag2")) + * ``` + * + * @param array The array expression to check. + * @param arrayExpression The elements to check for in the array. + * @return A new [BooleanExpression] representing the arrayContainsAll operation. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAll(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if array field contains all the specified [values]. + * + * ```kotlin + * // Check if the 'tags' array contains both "internal" and "public" + * arrayContainsAll("tags", listOf("internal", "public")) + * ``` + * + * @param arrayFieldName The name of field that contains array to check. + * @param values The elements to check for in the array. + * @return A new [BooleanExpression] representing the arrayContainsAll operation. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAll(java.lang.String arrayFieldName, java.util.List values) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if array field contains all elements of [arrayExpression]. + * + * ```kotlin + * // Check if the 'permissions' array contains all the required permissions + * arrayContainsAll("permissions", field("requiredPermissions")) + * ``` + * + * @param arrayFieldName The name of field that contains array to check. + * @param arrayExpression The elements to check for in the array. + * @return A new [BooleanExpression] representing the arrayContainsAll operation. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAll(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if [array] contains any of the specified [values]. + * + * ```kotlin + * // Check if the 'categories' array contains either values from field "cate1" or "cate2" + * arrayContainsAny(field("categories"), listOf(field("cate1"), field("cate2"))) + * ``` + * + * @param array The array expression to check. + * @param values The elements to check for in the array. + * @return A new [BooleanExpression] representing the arrayContainsAny operation. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAny(com.google.firebase.firestore.pipeline.Expression array, java.util.List values) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if [array] contains any elements of [arrayExpression]. + * + * ```kotlin + * // Check if the 'groups' array contains either the value from the 'userGroup' field + * // or the value "guest" + * arrayContainsAny(field("groups"), array(field("userGroup"), "guest")) + * ``` + * + * @param array The array expression to check. + * @param arrayExpression The elements to check for in the array. + * @return A new [BooleanExpression] representing the arrayContainsAny operation. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAny(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if array field contains any of the specified [values]. + * + * ```kotlin + * // Check if the 'roles' array contains "admin" or "editor" + * arrayContainsAny("roles", listOf("admin", "editor")) + * ``` + * + * @param arrayFieldName The name of field that contains array to check. + * @param values The elements to check for in the array. + * @return A new [BooleanExpression] representing the arrayContainsAny operation. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAny(java.lang.String arrayFieldName, java.util.List values) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if array field contains any elements of [arrayExpression]. + * + * ```kotlin + * // Check if the 'userGroups' array contains any of the 'targetGroups' + * arrayContainsAny("userGroups", field("targetGroups")) + * ``` + * + * @param arrayFieldName The name of field that contains array to check. + * @param arrayExpression The elements to check for in the array. + * @return A new [BooleanExpression] representing the arrayContainsAny operation. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAny(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the length of an [array] expression. + * + * ```kotlin + * // Get the number of items in the 'cart' array + * arrayLength(field("cart")) + * ``` + * + * @param array The array expression to calculate the length of. + * @return A new [Expression] representing the length of the array. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayLength(com.google.firebase.firestore.pipeline.Expression array) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the length of an array field. + * + * ```kotlin + * // Get the number of items in the 'cart' array + * arrayLength("cart") + * ``` + * + * @param arrayFieldName The name of the field containing an array to calculate the length of. + * @return A new [Expression] representing the length of the array. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayLength(java.lang.String arrayFieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first element of an [array] expression. + * + * ```kotlin + * // Get the first element of the 'myArray' field. + * arrayFirst(field("myArray")) + * ``` + * + * @param array The array expression to get the first element from. + * @return A new [Expression] representing the first element. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayFirst(com.google.firebase.firestore.pipeline.Expression array) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first element of an array field. + * + * ```kotlin + * // Get the first element of the 'myArray' field. + * arrayFirst("myArray") + * ``` + * + * @param arrayFieldName The name of the field containing an array to get the first element + * from. + * @return A new [Expression] representing the first element. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayFirst(java.lang.String arrayFieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first `n` elements of an [array] expression. + * + * ```kotlin + * // Get the first 3 elements of the 'myArray' field. + * arrayFirstN(field("myArray"), 3) + * ``` + * + * @param array The array expression. + * @param n The number of elements to return. + * @return A new [Expression] representing the first `n` elements. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayFirstN(com.google.firebase.firestore.pipeline.Expression array, int n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first `n` elements of an [array] expression. + * + * ```kotlin + * // Get the first n elements of the 'myArray' field. + * arrayFirstN(field("myArray"), field("count")) + * ``` + * + * @param array The array expression. + * @param n An expression evaluating to the number of elements to return. + * @return A new [Expression] representing the first `n` elements. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayFirstN(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first `n` elements of an array field. + * + * ```kotlin + * // Get the first n elements of the 'myArray' field. + * arrayFirstN("myArray", field("count")) + * ``` + * + * @param arrayFieldName The name of the field containing an array to get the first `n` elements + * from. + * @param n An expression evaluating to the number of elements to return. + * @return A new [Expression] representing the first `n` elements. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayFirstN(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first `n` elements of an array field. + * + * ```kotlin + * // Get the first n elements of the 'myArray' field. + * arrayFirstN("myArray", 3) + * ``` + * + * @param arrayFieldName The name of the field containing an array to get the first `n` elements + * from. + * @param n The number of elements to return. + * @return A new [Expression] representing the first `n` elements. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayFirstN(java.lang.String arrayFieldName, int n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the last element of an [array] expression. + * + * ```kotlin + * // Get the last element of the 'myArray' field. + * arrayLast(field("myArray")) + * ``` + * + * @param array The array expression to get the last element from. + * @return A new [Expression] representing the last element. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayLast(com.google.firebase.firestore.pipeline.Expression array) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the last element of an array field. + * + * ```kotlin + * // Get the last element of the 'myArray' field. + * arrayLast("myArray") + * ``` + * + * @param arrayFieldName The name of the field containing an array to get the last element from. + * @return A new [Expression] representing the last element. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayLast(java.lang.String arrayFieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the last `n` elements of an [array] expression. + * + * ```kotlin + * // Get the last 3 elements of the 'myArray' field. + * arrayLastN(field("myArray"), 3) + * ``` + * + * @param array The array expression. + * @param n The number of elements to return. + * @return A new [Expression] representing the last `n` elements. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayLastN(com.google.firebase.firestore.pipeline.Expression array, int n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the last `n` elements of an [array] expression. + * + * ```kotlin + * // Get the last n elements of the 'myArray' field. + * arrayLastN(field("myArray"), field("count")) + * ``` + * + * @param array The array expression. + * @param n An expression evaluating to the number of elements to return. + * @return A new [Expression] representing the last `n` elements. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayLastN(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the last `n` elements of an array field. + * + * ```kotlin + * // Get the last n elements of the 'myArray' field. + * arrayLastN("myArray", field("count")) + * ``` + * + * @param arrayFieldName The name of the field containing an array to get the last `n` elements + * from. + * @param n An expression evaluating to the number of elements to return. + * @return A new [Expression] representing the last `n` elements. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayLastN(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the last `n` elements of an array field. + * + * ```kotlin + * // Get the last n elements of the 'myArray' field. + * arrayLastN("myArray", 3) + * ``` + * + * @param arrayFieldName The name of the field containing an array to get the last `n` elements + * from. + * @param n The number of elements to return. + * @return A new [Expression] representing the last `n` elements. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayLastN(java.lang.String arrayFieldName, int n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the minimum element of the [array]. + * + * ```kotlin + * // Get the minimum element of the 'myArray' field. + * arrayMinimum(field("myArray")) + * ``` + * + * @param array The array expression. + * @return A new [Expression] representing the minimum element. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayMinimum(com.google.firebase.firestore.pipeline.Expression array) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the minimum element of an array field. + * + * ```kotlin + * // Get the minimum element of the 'myArray' field. + * arrayMinimum("myArray") + * ``` + * + * @param arrayFieldName The name of the field containing an array to get the minimum element + * from. + * @return A new [Expression] representing the minimum element. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayMinimum(java.lang.String arrayFieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first `n` smallest elements of the [array]. + * + * Note: Returns the n smallest non-null elements in the array, in ascending order. This does + * not use a stable sort, meaning the order of equivalent elements is undefined. + * + * ```kotlin + * // Get the 3 smallest elements of the 'myArray' field. + * arrayMinimumN(field("myArray"), 3) + * ``` + * + * @param array The array expression. + * @param n The number of elements to return. + * @return A new [Expression] representing the first `n` smallest elements. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayMinimumN(com.google.firebase.firestore.pipeline.Expression array, int n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first `n` smallest elements of the [array]. + * + * Note: Returns the n smallest non-null elements in the array, in ascending order. This does + * not use a stable sort, meaning the order of equivalent elements is undefined. + * + * ```kotlin + * // Get the n smallest elements of the 'myArray' field. + * arrayMinimumN(field("myArray"), field("count")) + * ``` + * + * @param array The array expression. + * @param n An expression evaluating to the number of elements to return. + * @return A new [Expression] representing the first `n` smallest elements. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayMinimumN(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first `n` smallest elements of the [array]. + * + * Note: Returns the n smallest non-null elements in the array, in ascending order. This does + * not use a stable sort, meaning the order of equivalent elements is undefined. + * + * ```kotlin + * // Get the n smallest elements of the 'myArray' field. + * arrayMinimumN("myArray", field("count")) + * ``` + * + * @param arrayFieldName The name of the field containing an array to get the first `n` smallest + * elements from. + * @param n An expression evaluating to the number of elements to return. + * @return A new [Expression] representing the first `n` smallest elements. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayMinimumN(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first `n` smallest elements of the [array]. + * + * Note: Returns the n smallest non-null elements in the array, in ascending order. This does + * not use a stable sort, meaning the order of equivalent elements is undefined. + * + * ```kotlin + * // Get the 3 smallest elements of the 'myArray' field. + * arrayMinimumN("myArray", 3) + * ``` + * + * @param arrayFieldName The name of the field containing an array to get the first `n` smallest + * elements from. + * @param n The number of elements to return. + * @return A new [Expression] representing the first `n` smallest elements. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayMinimumN(java.lang.String arrayFieldName, int n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the maximum element of the [array]. + * + * ```kotlin + * // Get the maximum element of the 'myArray' field. + * arrayMaximum(field("myArray")) + * ``` + * + * @param array The array expression. + * @return A new [Expression] representing the maximum element. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayMaximum(com.google.firebase.firestore.pipeline.Expression array) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the maximum element of an array field. + * + * ```kotlin + * // Get the maximum element of the 'myArray' field. + * arrayMaximum("myArray") + * ``` + * + * @param arrayFieldName The name of the field containing an array to get the maximum element + * from. + * @return A new [Expression] representing the maximum element. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayMaximum(java.lang.String arrayFieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first `n` largest elements of the [array]. + * + * Note: Returns the n largest non-null elements in the array, in descending order. This does + * not use a stable sort, meaning the order of equivalent elements is undefined. + * + * ```kotlin + * // Get the 3 largest elements of the 'myArray' field. + * arrayMaximumN(field("myArray"), 3) + * ``` + * + * @param array The array expression. + * @param n The number of elements to return. + * @return A new [Expression] representing the first `n` largest elements. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayMaximumN(com.google.firebase.firestore.pipeline.Expression array, int n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first `n` largest elements of the [array]. + * + * Note: Returns the n largest non-null elements in the array, in descending order. This does + * not use a stable sort, meaning the order of equivalent elements is undefined. + * + * ```kotlin + * // Get the n largest elements of the 'myArray' field. + * arrayMaximumN(field("myArray"), field("count")) + * ``` + * + * @param array The array expression. + * @param n An expression evaluating to the number of elements to return. + * @return A new [Expression] representing the first `n` largest elements. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayMaximumN(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first `n` largest elements of the [array]. + * + * Note: Returns the n largest non-null elements in the array, in descending order. This does + * not use a stable sort, meaning the order of equivalent elements is undefined. + * + * ```kotlin + * // Get the 3 largest elements of the 'myArray' field. + * arrayMaximumN("myArray", 3) + * ``` + * + * @param arrayFieldName The name of the field containing an array to get the first `n` largest + * elements from. + * @param n The number of elements to return. + * @return A new [Expression] representing the first `n` largest elements. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayMaximumN(java.lang.String arrayFieldName, int n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first `n` largest elements of the [array]. + * + * Note: Returns the n largest non-null elements in the array, in descending order. This does + * not use a stable sort, meaning the order of equivalent elements is undefined. + * + * ```kotlin + * // Get the n largest elements of the 'myArray' field. + * arrayMaximumN("myArray", field("count")) + * ``` + * + * @param arrayFieldName The name of the field containing an array to get the first `n` largest + * elements from. + * @param n An expression evaluating to the number of elements to return. + * @return A new [Expression] representing the first `n` largest elements. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayMaximumN(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the index of the first occurrence of the specified [value] + * in the [array], or -1 if the value is not found. + * + * ```kotlin + * // Get the index of 'foo' in the 'tags' array field. + * arrayIndexOf(field("tags"), "foo") + * ``` + * + * @param array The array expression. + * @param value The value to search for. + * @return A new [Expression] representing the index of the value. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayIndexOf(com.google.firebase.firestore.pipeline.Expression array, java.lang.Object value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the index of the first occurrence of the specified [value] + * in the [array], or -1 if the value is not found. + * + * ```kotlin + * // Get the index of 'foo' in the 'tags' array field. + * arrayIndexOf(field("tags"), "foo") + * ``` + * + * @param arrayFieldName The name of the field containing an array to get the index of the value + * from. + * @param value The value to search for. + * @return A new [Expression] representing the index of the value. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayIndexOf(java.lang.String arrayFieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the index of the last occurrence of the specified [value] + * in the [array], or -1 if the value is not found. + * + * ```kotlin + * // Get the last index of 'foo' in the 'tags' array field. + * arrayLastIndexOf(field("tags"), "foo") + * ``` + * + * @param array The array expression. + * @param value The value to search for. + * @return A new [Expression] representing the last index of the value. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayLastIndexOf(com.google.firebase.firestore.pipeline.Expression array, java.lang.Object value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the index of the last occurrence of the specified [value] + * in the [array], or -1 if the value is not found. + * + * ```kotlin + * // Get the last index of 'foo' in the 'tags' array field. + * arrayLastIndexOf(field("tags"), "foo") + * ``` + * + * @param arrayFieldName The name of the field containing an array to get the last index of the + * value from. + * @param value The value to search for. + * @return A new [Expression] representing the last index of the value. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayLastIndexOf(java.lang.String arrayFieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a list of all indices where the specified [value] occurs + * in the [array]. + * + * ```kotlin + * // Get all indices of 'foo' in the 'tags' array field. + * arrayIndexOfAll(field("tags"), "foo") + * ``` + * + * @param array The array expression. + * @param value The value to search for. + * @return A new [Expression] representing the list of indices. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayIndexOfAll(com.google.firebase.firestore.pipeline.Expression array, java.lang.Object value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a list of all indices where the specified [value] occurs + * in the [array]. + * + * ```kotlin + * // Get all indices of 'foo' in the 'tags' array field. + * arrayIndexOfAll(field("tags"), "foo") + * ``` + * + * @param arrayFieldName The name of the field containing an array to get the indices of the + * value from. + * @param value The value to search for. + * @return A new [Expression] representing the list of indices. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayIndexOfAll(java.lang.String arrayFieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that indexes into an array from the beginning or end and return the + * element. If the offset exceeds the array length, an error is returned. A negative offset, + * starts from the end. + * + * ```kotlin + * // Return the value in the tags field array at index specified by field 'favoriteTag'. + * arrayGet(field("tags"), field("favoriteTag")) + * ``` + * + * @param array An [Expression] evaluating to an array. + * @param offset An Expression evaluating to the index of the element to return. + * @return A new [Expression] representing the arrayOffset operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayGet(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression offset) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that indexes into an array from the beginning or end and return the + * element. If the offset exceeds the array length, an error is returned. A negative offset, + * starts from the end. + * + * ```kotlin + * // Return the value in the 'tags' field array at index `1`. + * arrayGet(field("tags"), 1) + * ``` + * + * @param array An [Expression] evaluating to an array. + * @param offset The index of the element to return. + * @return A new [Expression] representing the arrayOffset operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayGet(com.google.firebase.firestore.pipeline.Expression array, int offset) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that indexes into an array from the beginning or end and return the + * element. If the offset exceeds the array length, an error is returned. A negative offset, + * starts from the end. + * + * ```kotlin + * // Return the value in the tags field array at index specified by field 'favoriteTag'. + * arrayGet("tags", field("favoriteTag")) + * ``` + * + * @param arrayFieldName The name of an array field. + * @param offset An Expression evaluating to the index of the element to return. + * @return A new [Expression] representing the arrayOffset operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayGet(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression offset) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that indexes into an array from the beginning or end and return the + * element. If the offset exceeds the array length, an error is returned. A negative offset, + * starts from the end. + * + * ```kotlin + * // Return the value in the 'tags' field array at index `1`. + * arrayGet("tags", 1) + * ``` + * + * @param arrayFieldName The name of an array field. + * @param offset The index of the element to return. + * @return A new [Expression] representing the arrayOffset operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression arrayGet(java.lang.String arrayFieldName, int offset) { throw new RuntimeException("Stub!"); } + +/** + * Creates a conditional expression that evaluates to a [thenExpr] expression if a condition is + * true or an [elseExpr] expression if the condition is false. + * + * @param condition The condition to evaluate. + * @param thenExpr The expression to evaluate if the condition is true. + * @param elseExpr The expression to evaluate if the condition is false. + * @return A new [Expression] representing the conditional operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression conditional(com.google.firebase.firestore.pipeline.BooleanExpression condition, com.google.firebase.firestore.pipeline.Expression thenExpr, com.google.firebase.firestore.pipeline.Expression elseExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates a conditional expression that evaluates to a [thenValue] if a condition is true or an + * [elseValue] if the condition is false. + * + * ```kotlin + * // If the 'quantity' field is greater than 10, return "High", otherwise return "Low" + * conditional(field("quantity").greaterThan(10), "High", "Low") + * ``` + * + * @param condition The condition to evaluate. + * @param thenValue Value if the condition is true. + * @param elseValue Value if the condition is false. + * @return A new [Expression] representing the conditional operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression conditional(com.google.firebase.firestore.pipeline.BooleanExpression condition, java.lang.Object thenValue, java.lang.Object elseValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field exists. + * + * @param value An expression evaluates to the name of the field to check. + * @return A new [Expression] representing the exists check. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression exists(com.google.firebase.firestore.pipeline.Expression value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field exists. + * + * @param fieldName The field name to check. + * @return A new [Expression] representing the exists check. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression exists(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [catchExpr] argument if there is an error, else return + * the result of the [tryExpr] argument evaluation. + * + * ```kotlin + * // Returns the first item in the title field arrays, or returns + * // the entire title field if the array is empty or the field is another type. + * ifError(arrayGet(field("title"), 0), field("title")) + * ``` + * + * @param tryExpr The try expression. + * @param catchExpr The catch expression that will be evaluated and returned if the [tryExpr] + * produces an error. + * @return A new [Expression] representing the ifError operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression ifError(com.google.firebase.firestore.pipeline.Expression tryExpr, com.google.firebase.firestore.pipeline.Expression catchExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [catchExpr] argument if there is an error, else return + * the result of the [tryExpr] argument evaluation. + * + * This overload will return [BooleanExpression] when both parameters are also + * [BooleanExpression]. + * + * ```kotlin + * // Returns the result of the boolean expression, or false if it errors. + * ifError(field("is_premium"), false) + * ``` + * + * @param tryExpr The try boolean expression. + * @param catchExpr The catch boolean expression that will be evaluated and returned if the + * [tryExpr] produces an error. + * @return A new [BooleanExpression] representing the ifError operation. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression ifError(com.google.firebase.firestore.pipeline.BooleanExpression tryExpr, com.google.firebase.firestore.pipeline.BooleanExpression catchExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a given expression produces an error. + * + * ```kotlin + * // Check if the result of a calculation is an error + * isError(arrayContains(field("title"), 1)) + * ``` + * + * @param expr The expression to check. + * @return A new [BooleanExpression] representing the `isError` check. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression isError(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [catchValue] argument if there is an error, else + * return the result of the [tryExpr] argument evaluation. + * + * ```kotlin + * // Returns the first item in the title field arrays, or returns "Default Title" + * ifError(arrayGet(field("title"), 0), "Default Title") + * ``` + * + * @param tryExpr The try expression. + * @param catchValue The value that will be returned if the [tryExpr] produces an error. + * @return A new [Expression] representing the ifError operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression ifError(com.google.firebase.firestore.pipeline.Expression tryExpr, java.lang.Object catchValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [elseExpr] argument if [ifExpr] is absent, else return + * the result of the [ifExpr] argument evaluation. + * + * ```kotlin + * // Returns the value of the optional field 'optional_field', or returns 'default_value' + * // if the field is absent. + * ifAbsent(field("optional_field"), "default_value") + * ``` + * + * @param ifExpr The expression to check for absence. + * @param elseExpr The expression that will be evaluated and returned if [ifExpr] is absent. + * @return A new [Expression] representing the ifAbsent operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression ifAbsent(com.google.firebase.firestore.pipeline.Expression ifExpr, com.google.firebase.firestore.pipeline.Expression elseExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [elseValue] argument if [ifExpr] is absent, else + * return the result of the [ifExpr] argument evaluation. + * + * ```kotlin + * // Returns the value of the optional field 'optional_field', or returns 'default_value' + * // if the field is absent. + * ifAbsent(field("optional_field"), "default_value") + * ``` + * + * @param ifExpr The expression to check for absence. + * @param elseValue The value that will be returned if [ifExpr] is absent. + * @return A new [Expression] representing the ifAbsent operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression ifAbsent(com.google.firebase.firestore.pipeline.Expression ifExpr, java.lang.Object elseValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [elseExpr] argument if [ifFieldName] is absent, else + * return the value of the field. + * + * ```kotlin + * // Returns the value of the optional field 'optional_field', or returns the value of + * // 'default_field' if 'optional_field' is absent. + * ifAbsent("optional_field", field("default_field")) + * ``` + * + * @param ifFieldName The field to check for absence. + * @param elseExpr The expression that will be evaluated and returned if [ifFieldName] is + * absent. + * @return A new [Expression] representing the ifAbsent operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression ifAbsent(java.lang.String ifFieldName, com.google.firebase.firestore.pipeline.Expression elseExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [elseValue] argument if [ifFieldName] is absent, else + * return the value of the field. + * + * ```kotlin + * // Returns the value of the optional field 'optional_field', or returns 'default_value' + * // if the field is absent. + * ifAbsent("optional_field", "default_value") + * ``` + * + * @param ifFieldName The field to check for absence. + * @param elseValue The value that will be returned if [ifFieldName] is absent. + * @return A new [Expression] representing the ifAbsent operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression ifAbsent(java.lang.String ifFieldName, java.lang.Object elseValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [elseExpr] argument if [ifExpr] evaluates to null, + * else return the result of the [ifExpr] argument evaluation. + * + * This function provides a fallback for both absent and explicit null values. In contrast, + * [ifAbsent] only triggers for missing fields. + * + * ```kotlin + * // Returns the user's preferred name, or if that is null, returns their full name. + * ifNull(field("preferredName"), field("fullName")) + * ``` + * + * @param ifExpr The expression to check for null. + * @param elseExpr The expression that will be evaluated and returned if [ifExpr] is null. + * @return A new [Expression] representing the ifNull operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression ifNull(com.google.firebase.firestore.pipeline.Expression ifExpr, com.google.firebase.firestore.pipeline.Expression elseExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [elseValue] argument if [ifExpr] evaluates to null, + * else return the result of the [ifExpr] argument evaluation. + * + * This function provides a fallback for both absent and explicit null values. In contrast, + * [ifAbsent] only triggers for missing fields. + * + * ```kotlin + * // Returns the user's display name, or returns "Anonymous" if the field is null. + * ifNull(field("displayName"), "Anonymous") + * ``` + * + * @param ifExpr The expression to check for null. + * @param elseValue The value that will be returned if [ifExpr] evaluates to null. + * @return A new [Expression] representing the ifNull operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression ifNull(com.google.firebase.firestore.pipeline.Expression ifExpr, java.lang.Object elseValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [elseExpr] argument if [ifFieldName] field is null, + * else return the value of the field. + * + * ```kotlin + * // Returns the user's preferred name, or if that is null, returns their full name. + * ifNull("preferredName", field("fullName")) + * ``` + * + * @param ifFieldName The field to check for null. + * @param elseExpr The expression that will be evaluated and returned if [ifFieldName] is null. + * @return A new [Expression] representing the ifNull operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression ifNull(java.lang.String ifFieldName, com.google.firebase.firestore.pipeline.Expression elseExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [elseValue] argument if [ifFieldName] field is null, + * else return the value of the field. + * + * ```kotlin + * // Returns the user's display name, or returns "Anonymous" if the field is null. + * ifNull("displayName", "Anonymous") + * ``` + * + * @param ifFieldName The field to check for null. + * @param elseValue The value that will be returned if [ifFieldName] is null. + * @return A new [Expression] representing the ifNull operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression ifNull(java.lang.String ifFieldName, java.lang.Object elseValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first non-null, non-absent argument, without + * evaluating the rest of the arguments. When all arguments are null or absent, returns the last + * argument. + * + * ```kotlin + * // Returns the value of the first non-null, non-absent field among 'preferredName', 'fullName', + * // or the last argument if all previous fields are null. + * coalesce(field("preferredName"), field("fullName"), constant("Anonymous")) + * ``` + * + * @param expression The first expression to check for null. + * @param replacement The fallback expression or value if the first one is null. + * @param others Optional additional expressions to check if previous ones are null. + * @return A new [Expression] representing the coalesce operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression coalesce(com.google.firebase.firestore.pipeline.Expression expression, java.lang.Object replacement, java.lang.Object... others) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first non-null, non-absent argument, without + * evaluating the rest of the arguments. When all arguments are null or absent, returns the last + * argument. + * + * ```kotlin + * // Returns the value of the first non-null, non-absent field among 'preferredName', 'fullName', + * // or the last argument if all previous fields are null. + * coalesce("preferredName", field("fullName"), constant("Anonymous")) + * ``` + * + * @param fieldName The name of the first field to check for null. + * @param replacement The fallback expression or value if the first one is null. + * @param others Optional additional expressions to check if previous ones are null. + * @return A new [Expression] representing the coalesce operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression coalesce(java.lang.String fieldName, java.lang.Object replacement, java.lang.Object... others) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the collection ID from a path. + * + * ```kotlin + * // Get the collection ID from the 'path' field + * collectionId(field("path")) + * ``` + * + * @param path An expression the evaluates to a path. + * @return A new [Expression] representing the collectionId operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression collectionId(com.google.firebase.firestore.pipeline.Expression path) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the collection ID from a path. + * + * ```kotlin + * // Get the collection ID from a path field + * collectionId("pathField") + * ``` + * + * @param pathField The string representation of the path. + * @return A new [Expression] representing the collectionId operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression collectionId(java.lang.String pathField) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the document ID from a path. + * + * ```kotlin + * // Get the document ID from the 'path' field + * documentId(field("path")) + * ``` + * + * @param documentPath An expression the evaluates to document path. + * @return A new [Expression] representing the documentId operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression documentId(com.google.firebase.firestore.pipeline.Expression documentPath) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the document ID from a path. + * + * ```kotlin + * // Get the document ID from a path string + * documentId("projects/p/databases/d/documents/c/d") + * ``` + * + * @param documentPath The string representation of the document path. + * @return A new [Expression] representing the documentId operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression documentId(java.lang.String documentPath) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the document ID from a [DocumentReference]. + * + * @param docRef The [DocumentReference]. + * @return A new [Expression] representing the documentId operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression documentId(com.google.firebase.firestore.DocumentReference docRef) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the parent document reference of a document reference. + * + * ```kotlin + * // Get the parent document reference of a document reference. + * parent(field("__path__")) + * ``` + * + * @param documentPath An expression evaluating to a document reference. + * @return A new [Expression] representing the parent operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression parent(com.google.firebase.firestore.pipeline.Expression documentPath) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the parent document reference of a document reference. + * + * ```kotlin + * // Get the parent document reference of a document reference. + * parent("projects/p/databases/d/documents/c/d") + * ``` + * + * @param documentPath A string path to get the parent from. + * @return A new [Expression] representing the parent operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression parent(java.lang.String documentPath) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the parent document reference of a document reference. + * + * ```kotlin + * // Get the parent document reference of a document reference. + * parent(myDocumentReference) + * ``` + * + * @param docRef A [DocumentReference] to get the parent from. + * @return A new [Expression] representing the parent operation. + */ + +public static final com.google.firebase.firestore.pipeline.Expression parent(com.google.firebase.firestore.DocumentReference docRef) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that retrieves the value of a variable bound via [Pipeline.define]. + * + * Example: + * ```kotlin + * firestore.pipeline().collection("products") + * .define( + * multiply(field("price"), 0.9).as("discountedPrice"), + * add(field("stock"), 10).as("newStock") + * ) + * .where(lessThan(variable("discountedPrice"), 100)) + * .select(field("name"), variable("newStock")); + * ``` + * + * @param name The name of the variable to retrieve. + * @return An [Expression] representing the variable's value. + */ + +public static final com.google.firebase.firestore.pipeline.Expression variable(java.lang.String name) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that represents the current document being processed. + * + * Example: + * ```kotlin + * // Define the current document as a variable "doc" + * firestore.pipeline().collection("books") + * .define(currentDocument().alias("doc")) + * // Access a field from the defined document variable + * .select(variable("doc").getField("title")) + * ``` + * + * @return An [Expression] representing the current document. + */ + +public static final com.google.firebase.firestore.pipeline.Expression currentDocument() { throw new RuntimeException("Stub!"); } + +/** + * Evaluates to the distance in meters between the location in the specified field and the query + * location. + * + * Note: This Expression can only be used within a `Search` stage. + * + * @example + * ```kotlin + * db.pipeline().collection("restaurants").search( + * SearchStage(query = documentMatches("waffles"), sort = arrayOf(geoDistance("location", GeoPoint(37.0, -122.0)).ascending())) + * ) + * ``` + * + * @param fieldName Specifies the field in the document which contains the first GeoPoint for + * distance computation. + * @param location Compute distance to this GeoPoint. + */ + +public static final com.google.firebase.firestore.pipeline.Expression geoDistance(java.lang.String fieldName, com.google.firebase.firestore.GeoPoint location) { throw new RuntimeException("Stub!"); } + +/** + * Evaluates to the distance in meters between the location in the specified field and the query + * location. + * + * Note: This Expression can only be used within a `Search` stage. + * + * @example + * ```kotlin + * db.pipeline().collection("restaurants").search( + * SearchStage(query = documentMatches("waffles"), sort = arrayOf(geoDistance(field("location"), GeoPoint(37.0, -122.0)).ascending())) + * ) + * ``` + * + * @param field Specifies the field in the document which contains the first GeoPoint for + * distance computation. + * @param location Compute distance to this GeoPoint. + */ + +public static final com.google.firebase.firestore.pipeline.Expression geoDistance(com.google.firebase.firestore.pipeline.Field field, com.google.firebase.firestore.GeoPoint location) { throw new RuntimeException("Stub!"); } + +/** + * Perform a full-text search on all indexed search fields in the document. + * + * Note: This Expression can only be used within a `Search` stage. + * + * @example + * ```kotlin + * db.pipeline().collection("restaurants").search( + * SearchStage(query = documentMatches("waffles OR pancakes")) + * ) + * ``` + * + * @param rquery Define the search query using the search DSL. + */ + +public static final com.google.firebase.firestore.pipeline.BooleanExpression documentMatches(java.lang.String rquery) { throw new RuntimeException("Stub!"); } + +/** + * Evaluates to the search score that reflects the topicality of the document to all of the text + * predicates (for example: `documentMatches`) in the search query. If `SearchStage.query` is + * not set or does not contain any text predicates, then this score will always be `0`. + * + * Note: This Expression can only be used within a `Search` stage. + * @example + * ```kotlin + * db.pipeline().collection("restaurants").search( + * SearchStage(query = documentMatches("waffles"), sort = arrayOf(score().descending())) + * ) + * ``` + */ + +public static final com.google.firebase.firestore.pipeline.Expression score() { throw new RuntimeException("Stub!"); } + +public static final com.google.firebase.firestore.pipeline.Expression.Companion Companion; +static { Companion = null; } +@SuppressWarnings({"unchecked", "deprecation", "all"}) +public static final class Companion { + +Companion() { throw new RuntimeException("Stub!"); } + +/** + * Create a constant for a [String] value. + * + * ```kotlin + * // Create a constant with the value "hello" + * constant("hello") + * ``` + * + * @param value The [String] value. + * @return A new [Expression] constant instance. + */ + +public com.google.firebase.firestore.pipeline.Expression constant(java.lang.String value) { throw new RuntimeException("Stub!"); } + +/** + * Create a constant for a [Number] value. + * + * ```kotlin + * // Create a constant with the value 123 + * constant(123) + * ``` + * + * @param value The [Number] value. + * @return A new [Expression] constant instance. + */ + +public com.google.firebase.firestore.pipeline.Expression constant(java.lang.Number value) { throw new RuntimeException("Stub!"); } + +/** + * Create a constant for a [Date] value. + * + * ```kotlin + * // Create a constant with the current date + * constant(Date()) + * ``` + * + * @param value The [Date] value. + * @return A new [Expression] constant instance. + */ + +public com.google.firebase.firestore.pipeline.Expression constant(java.util.Date value) { throw new RuntimeException("Stub!"); } + +/** + * Create a constant for a [Timestamp] value. + * + * ```kotlin + * // Create a constant with the current timestamp + * constant(Timestamp.now()) + * ``` + * + * @param value The [Timestamp] value. + * @return A new [Expression] constant instance. + */ + +public com.google.firebase.firestore.pipeline.Expression constant(com.google.firebase.Timestamp value) { throw new RuntimeException("Stub!"); } + +/** + * Create a constant for a [Boolean] value. + * + * ```kotlin + * // Create a constant with the value true + * constant(true) + * ``` + * + * @param value The [Boolean] value. + * @return A new [BooleanExpression] constant instance. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression constant(boolean value) { throw new RuntimeException("Stub!"); } + +/** + * Create a constant for a [GeoPoint] value. + * + * ```kotlin + * // Create a constant with a GeoPoint + * constant(GeoPoint(37.7749, -122.4194)) + * ``` + * + * @param value The [GeoPoint] value. + * @return A new [Expression] constant instance. + */ + +public com.google.firebase.firestore.pipeline.Expression constant(com.google.firebase.firestore.GeoPoint value) { throw new RuntimeException("Stub!"); } + +/** + * Create a constant for a bytes value. + * + * ```kotlin + * // Create a constant with a byte array + * constant(byteArrayOf(0x48, 0x65, 0x6c, 0x6c, 0x6f)) // "Hello" + * ``` + * + * @param value The bytes value. + * @return A new [Expression] constant instance. + */ + +public com.google.firebase.firestore.pipeline.Expression constant(byte[] value) { throw new RuntimeException("Stub!"); } + +/** + * Create a constant for a [Blob] value. + * + * ```kotlin + * // Create a constant with a Blob + * constant(Blob.fromBytes(byteArrayOf(0x48, 0x65, 0x6c, 0x6c, 0x6f))) // "Hello" + * ``` + * + * @param value The [Blob] value. + * @return A new [Expression] constant instance. + */ + +public com.google.firebase.firestore.pipeline.Expression constant(com.google.firebase.firestore.Blob value) { throw new RuntimeException("Stub!"); } + +/** + * Create a constant for a [DocumentReference] value. + * + * ```kotlin + * // val firestore = FirebaseFirestore.getInstance() + * // val docRef = firestore.collection("cities").document("SF") + * // constant(docRef) + * ``` + * + * @param ref The [DocumentReference] value. + * @return A new [Expression] constant instance. + */ + +public com.google.firebase.firestore.pipeline.Expression constant(com.google.firebase.firestore.DocumentReference ref) { throw new RuntimeException("Stub!"); } + +/** + * Create a constant for a [VectorValue] value. + * + * ```kotlin + * // Create a constant with a VectorValue + * constant(VectorValue(listOf(1.0, 2.0, 3.0))) + * ``` + * + * @param value The [VectorValue] value. + * @return A new [Expression] constant instance. + */ + +public com.google.firebase.firestore.pipeline.Expression constant(com.google.firebase.firestore.VectorValue value) { throw new RuntimeException("Stub!"); } + +/** + * Constant for a null value. + * + * ```kotlin + * // Create a null constant + * nullValue() + * ``` + * + * @return A [Expression] constant instance. + */ + +public com.google.firebase.firestore.pipeline.Expression nullValue() { throw new RuntimeException("Stub!"); } + +/** + * Create a vector constant for a [DoubleArray] value. + * + * ```kotlin + * // Create a vector constant from a DoubleArray + * vector(doubleArrayOf(1.0, 2.0, 3.0)) + * ``` + * + * @param vector The [DoubleArray] value. + * @return A [Expression] constant instance. + */ + +public com.google.firebase.firestore.pipeline.Expression vector(double[] vector) { throw new RuntimeException("Stub!"); } + +/** + * Create a vector constant for a [VectorValue] value. + * + * ```kotlin + * // Create a vector constant from a VectorValue + * vector(VectorValue(listOf(1.0, 2.0, 3.0))) + * ``` + * + * @param vector The [VectorValue] value. + * @return A [Expression] constant instance. + */ + +public com.google.firebase.firestore.pipeline.Expression vector(com.google.firebase.firestore.VectorValue vector) { throw new RuntimeException("Stub!"); } + +/** + * Creates a [Field] instance representing the field at the given path. + * + * The path can be a simple field name (e.g., "name") or a dot-separated path to a nested field + * (e.g., "address.city"). + * + * @param name The path to the field. + * @return A new [Field] instance representing the specified path. + */ + +public com.google.firebase.firestore.pipeline.Field field(java.lang.String name) { throw new RuntimeException("Stub!"); } + +/** + * Creates a [Field] instance representing the field at the given path. + * + * The path can be a simple field name (e.g., "name") or a dot-separated path to a nested field + * (e.g., "address.city"). + * + * ```kotlin + * // Get the 'address.city' field + * field(FieldPath.of("address", "city")) + * ``` + * + * @param fieldPath The [FieldPath] to the field. + * @return A new [Field] instance representing the specified path. + */ + +public com.google.firebase.firestore.pipeline.Field field(com.google.firebase.firestore.FieldPath fieldPath) { throw new RuntimeException("Stub!"); } + +/** + * Creates a 'raw' function expression. This is useful if the expression is available in the + * backend, but not yet in the current version of the SDK yet. + * + * ```kotlin + * // Create a generic function call + * rawFunction("my_function", field("arg1"), constant(42)) + * ``` + * + * @param name The name of the raw function. + * @param expr The expressions to be passed as arguments to the function. + * @return A new [Expression] representing the raw function. + */ + +public com.google.firebase.firestore.pipeline.Expression rawFunction(java.lang.String name, com.google.firebase.firestore.pipeline.Expression... expr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that performs a logical 'AND' operation. + * + * ```kotlin + * // Check if 'status' is "new" and 'priority' is greater than 1 + * and(field("status").equal("new"), field("priority").greaterThan(1)) + * ``` + * + * @param condition The first [BooleanExpression]. + * @param conditions Additional [BooleanExpression]s. + * @return A new [BooleanExpression] representing the logical 'AND' operation. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression and(com.google.firebase.firestore.pipeline.BooleanExpression condition, com.google.firebase.firestore.pipeline.BooleanExpression... conditions) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that performs a logical 'OR' operation. + * + * ```kotlin + * // Check if 'status' is "new" or "open" + * or(field("status").equal("new"), field("status").equal("open")) + * ``` + * + * @param condition The first [BooleanExpression]. + * @param conditions Additional [BooleanExpression]s. + * @return A new [BooleanExpression] representing the logical 'OR' operation. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression or(com.google.firebase.firestore.pipeline.BooleanExpression condition, com.google.firebase.firestore.pipeline.BooleanExpression... conditions) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that performs a logical 'NOR' operation. + * + * ```kotlin + * // Check if 'status' is neither "new" nor "open" + * nor(field("status").equal("new"), field("status").equal("open")) + * ``` + * + * @param condition The first [BooleanExpression]. + * @param conditions Additional [BooleanExpression]s. + * @return A new [BooleanExpression] representing the logical 'NOR' operation. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression nor(com.google.firebase.firestore.pipeline.BooleanExpression condition, com.google.firebase.firestore.pipeline.BooleanExpression... conditions) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that evaluates to the result corresponding to the first true condition. + * + * This function behaves like a `switch` statement. It accepts an alternating sequence of + * conditions and their corresponding results. If an odd number of arguments is provided, the + * final argument serves as a default fallback result. If no default is provided and no + * condition evaluates to true, it throws an error. + * + * ```kotlin + * // Return "Active" if field "status" is 1, "Pending" if field "status" is 2, + * // and default to "Unknown" if none of the conditions are true. + * switchOn( + * field("status").equal(1), constant("Active"), + * field("status").equal(2), constant("Pending"), + * constant("Unknown") + * ) + * ``` + * + * @param condition The first condition to check. + * @param result The result if the first condition is true. + * @param others Additional conditions and results, and optionally a default value. + * @return A new [Expression] representing the switch operation. + */ + +public com.google.firebase.firestore.pipeline.Expression switchOn(com.google.firebase.firestore.pipeline.BooleanExpression condition, java.lang.Object result, java.lang.Object... others) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that performs a logical 'XOR' operation. + * + * ```kotlin + * // Check if either 'a' is true or 'b' is true, but not both + * xor(field("a"), field("b")) + * ``` + * + * @param condition The first [BooleanExpression]. + * @param conditions Additional [BooleanExpression]s. + * @return A new [BooleanExpression] representing the logical 'XOR' operation. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression xor(com.google.firebase.firestore.pipeline.BooleanExpression condition, com.google.firebase.firestore.pipeline.BooleanExpression... conditions) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that negates a boolean expression. + * + * ```kotlin + * // Check if 'is_admin' is not true + * not(field("is_admin")) + * ``` + * + * @param condition The boolean expression to negate. + * @return A new [BooleanExpression] representing the not operation. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression not(com.google.firebase.firestore.pipeline.BooleanExpression condition) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise AND operation between two expressions. + * + * ```kotlin + * // Bitwise AND the value of the 'flags' field with the value of the 'mask' field. + * bitAnd(field("flags"), field("mask")) + * ``` + * + * @param bits An expression that returns bits when evaluated. + * @param bitsOther An expression that returns bits when evaluated. + * @return A new [Expression] representing the bitwise AND operation. + */ + +public com.google.firebase.firestore.pipeline.Expression bitAnd(com.google.firebase.firestore.pipeline.Expression bits, com.google.firebase.firestore.pipeline.Expression bitsOther) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise AND operation between an expression and a + * constant. + * + * ```kotlin + * // Bitwise AND the value of the 'flags' field with a constant mask. + * bitAnd(field("flags"), byteArrayOf(0b00001111)) + * ``` + * + * @param bits An expression that returns bits when evaluated. + * @param bitsOther A constant byte array. + * @return A new [Expression] representing the bitwise AND operation. + */ + +public com.google.firebase.firestore.pipeline.Expression bitAnd(com.google.firebase.firestore.pipeline.Expression bits, byte[] bitsOther) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise AND operation between an field and an + * expression. + * + * ```kotlin + * // Bitwise AND the value of the 'flags' field with the value of the 'mask' field. + * bitAnd("flags", field("mask")) + * ``` + * + * @param bitsFieldName Name of field that contains bits data. + * @param bitsOther An expression that returns bits when evaluated. + * @return A new [Expression] representing the bitwise AND operation. + */ + +public com.google.firebase.firestore.pipeline.Expression bitAnd(java.lang.String bitsFieldName, com.google.firebase.firestore.pipeline.Expression bitsOther) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise AND operation between an field and constant. + * + * ```kotlin + * // Bitwise AND the value of the 'flags' field with a constant mask. + * bitAnd("flags", byteArrayOf(0b00001111)) + * ``` + * + * @param bitsFieldName Name of field that contains bits data. + * @param bitsOther A constant byte array. + * @return A new [Expression] representing the bitwise AND operation. + */ + +public com.google.firebase.firestore.pipeline.Expression bitAnd(java.lang.String bitsFieldName, byte[] bitsOther) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise OR operation between two expressions. + * + * ```kotlin + * // Bitwise OR the value of the 'flags' field with the value of the 'mask' field. + * bitOr(field("flags"), field("mask")) + * ``` + * + * @param bits An expression that returns bits when evaluated. + * @param bitsOther An expression that returns bits when evaluated. + * @return A new [Expression] representing the bitwise OR operation. + */ + +public com.google.firebase.firestore.pipeline.Expression bitOr(com.google.firebase.firestore.pipeline.Expression bits, com.google.firebase.firestore.pipeline.Expression bitsOther) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise OR operation between an expression and a + * constant. + * + * ```kotlin + * // Bitwise OR the value of the 'flags' field with a constant mask. + * bitOr(field("flags"), byteArrayOf(0b00001111)) + * ``` + * + * @param bits An expression that returns bits when evaluated. + * @param bitsOther A constant byte array. + * @return A new [Expression] representing the bitwise OR operation. + */ + +public com.google.firebase.firestore.pipeline.Expression bitOr(com.google.firebase.firestore.pipeline.Expression bits, byte[] bitsOther) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise OR operation between an field and an expression. + * + * ```kotlin + * // Bitwise OR the value of the 'flags' field with the value of the 'mask' field. + * bitOr("flags", field("mask")) + * ``` + * + * @param bitsFieldName Name of field that contains bits data. + * @param bitsOther An expression that returns bits when evaluated. + * @return A new [Expression] representing the bitwise OR operation. + */ + +public com.google.firebase.firestore.pipeline.Expression bitOr(java.lang.String bitsFieldName, com.google.firebase.firestore.pipeline.Expression bitsOther) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise OR operation between an field and constant. + * + * ```kotlin + * // Bitwise OR the value of the 'flags' field with a constant mask. + * bitOr("flags", byteArrayOf(0b00001111)) + * ``` + * + * @param bitsFieldName Name of field that contains bits data. + * @param bitsOther A constant byte array. + * @return A new [Expression] representing the bitwise OR operation. + */ + +public com.google.firebase.firestore.pipeline.Expression bitOr(java.lang.String bitsFieldName, byte[] bitsOther) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise XOR operation between two expressions. + * + * ```kotlin + * // Bitwise XOR the value of the 'flags' field with the value of the 'mask' field. + * bitXor(field("flags"), field("mask")) + * ``` + * + * @param bits An expression that returns bits when evaluated. + * @param bitsOther An expression that returns bits when evaluated. + * @return A new [Expression] representing the bitwise XOR operation. + */ + +public com.google.firebase.firestore.pipeline.Expression bitXor(com.google.firebase.firestore.pipeline.Expression bits, com.google.firebase.firestore.pipeline.Expression bitsOther) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise XOR operation between an expression and a + * constant. + * + * ```kotlin + * // Bitwise XOR the value of the 'flags' field with a constant mask. + * bitXor(field("flags"), byteArrayOf(0b00001111)) + * ``` + * + * @param bits An expression that returns bits when evaluated. + * @param bitsOther A constant byte array. + * @return A new [Expression] representing the bitwise XOR operation. + */ + +public com.google.firebase.firestore.pipeline.Expression bitXor(com.google.firebase.firestore.pipeline.Expression bits, byte[] bitsOther) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise XOR operation between an field and an + * expression. + * + * ```kotlin + * // Bitwise XOR the value of the 'flags' field with the value of the 'mask' field. + * bitXor("flags", field("mask")) + * ``` + * + * @param bitsFieldName Name of field that contains bits data. + * @param bitsOther An expression that returns bits when evaluated. + * @return A new [Expression] representing the bitwise XOR operation. + */ + +public com.google.firebase.firestore.pipeline.Expression bitXor(java.lang.String bitsFieldName, com.google.firebase.firestore.pipeline.Expression bitsOther) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise XOR operation between an field and constant. + * + * ```kotlin + * // Bitwise XOR the value of the 'flags' field with a constant mask. + * bitXor("flags", byteArrayOf(0b00001111)) + * ``` + * + * @param bitsFieldName Name of field that contains bits data. + * @param bitsOther A constant byte array. + * @return A new [Expression] representing the bitwise XOR operation. + */ + +public com.google.firebase.firestore.pipeline.Expression bitXor(java.lang.String bitsFieldName, byte[] bitsOther) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise NOT operation to an expression. + * + * ```kotlin + * // Bitwise NOT the value of the 'flags' field. + * bitNot(field("flags")) + * ``` + * + * @param bits An expression that returns bits when evaluated. + * @return A new [Expression] representing the bitwise NOT operation. + */ + +public com.google.firebase.firestore.pipeline.Expression bitNot(com.google.firebase.firestore.pipeline.Expression bits) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise NOT operation to a field. + * + * ```kotlin + * // Bitwise NOT the value of the 'flags' field. + * bitNot("flags") + * ``` + * + * @param bitsFieldName Name of field that contains bits data. + * @return A new [Expression] representing the bitwise NOT operation. + */ + +public com.google.firebase.firestore.pipeline.Expression bitNot(java.lang.String bitsFieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise left shift operation between two expressions. + * + * ```kotlin + * // Left shift the value of the 'bits' field by the value of the 'shift' field. + * bitLeftShift(field("bits"), field("shift")) + * ``` + * + * @param bits An expression that returns bits when evaluated. + * @param numberExpr The number of bits to shift. + * @return A new [Expression] representing the bitwise left shift operation. + */ + +public com.google.firebase.firestore.pipeline.Expression bitLeftShift(com.google.firebase.firestore.pipeline.Expression bits, com.google.firebase.firestore.pipeline.Expression numberExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise left shift operation between an expression and a + * constant. + * + * ```kotlin + * // Left shift the value of the 'bits' field by 2. + * bitLeftShift(field("bits"), 2) + * ``` + * + * @param bits An expression that returns bits when evaluated. + * @param number The number of bits to shift. + * @return A new [Expression] representing the bitwise left shift operation. + */ + +public com.google.firebase.firestore.pipeline.Expression bitLeftShift(com.google.firebase.firestore.pipeline.Expression bits, int number) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise left shift operation between a field and an + * expression. + * + * ```kotlin + * // Left shift the value of the 'bits' field by the value of the 'shift' field. + * bitLeftShift("bits", field("shift")) + * ``` + * + * @param bitsFieldName Name of field that contains bits data. + * @param numberExpr The number of bits to shift. + * @return A new [Expression] representing the bitwise left shift operation. + */ + +public com.google.firebase.firestore.pipeline.Expression bitLeftShift(java.lang.String bitsFieldName, com.google.firebase.firestore.pipeline.Expression numberExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise left shift operation between a field and a + * constant. + * + * ```kotlin + * // Left shift the value of the 'bits' field by 2. + * bitLeftShift("bits", 2) + * ``` + * + * @param bitsFieldName Name of field that contains bits data. + * @param number The number of bits to shift. + * @return A new [Expression] representing the bitwise left shift operation. + */ + +public com.google.firebase.firestore.pipeline.Expression bitLeftShift(java.lang.String bitsFieldName, int number) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise right shift operation between two expressions. + * + * ```kotlin + * // Right shift the value of the 'bits' field by the value of the 'shift' field. + * bitRightShift(field("bits"), field("shift")) + * ``` + * + * @param bits An expression that returns bits when evaluated. + * @param numberExpr The number of bits to shift. + * @return A new [Expression] representing the bitwise right shift operation. + */ + +public com.google.firebase.firestore.pipeline.Expression bitRightShift(com.google.firebase.firestore.pipeline.Expression bits, com.google.firebase.firestore.pipeline.Expression numberExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise right shift operation between an expression and + * a constant. + * + * ```kotlin + * // Right shift the value of the 'bits' field by 2. + * bitRightShift(field("bits"), 2) + * ``` + * + * @param bits An expression that returns bits when evaluated. + * @param number The number of bits to shift. + * @return A new [Expression] representing the bitwise right shift operation. + */ + +public com.google.firebase.firestore.pipeline.Expression bitRightShift(com.google.firebase.firestore.pipeline.Expression bits, int number) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise right shift operation between a field and an + * expression. + * + * ```kotlin + * // Right shift the value of the 'bits' field by the value of the 'shift' field. + * bitRightShift("bits", field("shift")) + * ``` + * + * @param bitsFieldName Name of field that contains bits data. + * @param numberExpr The number of bits to shift. + * @return A new [Expression] representing the bitwise right shift operation. + */ + +public com.google.firebase.firestore.pipeline.Expression bitRightShift(java.lang.String bitsFieldName, com.google.firebase.firestore.pipeline.Expression numberExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a bitwise right shift operation between a field and a + * constant. + * + * ```kotlin + * // Right shift the value of the 'bits' field by 2. + * bitRightShift("bits", 2) + * ``` + * + * @param bitsFieldName Name of field that contains bits data. + * @param number The number of bits to shift. + * @return A new [Expression] representing the bitwise right shift operation. + */ + +public com.google.firebase.firestore.pipeline.Expression bitRightShift(java.lang.String bitsFieldName, int number) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that rounds [numericExpr] to nearest integer. + * + * ```kotlin + * // Round the value of the 'price' field. + * round(field("price")) + * ``` + * + * Rounds away from zero in halfway cases. + * + * @param numericExpr An expression that returns number when evaluated. + * @return A new [Expression] representing an integer result from the round operation. + */ + +public com.google.firebase.firestore.pipeline.Expression round(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that rounds [numericField] to nearest integer. + * + * ```kotlin + * // Round the value of the 'price' field. + * round("price") + * ``` + * + * Rounds away from zero in halfway cases. + * + * @param numericField Name of field that returns number when evaluated. + * @return A new [Expression] representing an integer result from the round operation. + */ + +public com.google.firebase.firestore.pipeline.Expression round(java.lang.String numericField) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that rounds off [numericExpr] to [decimalPlace] decimal places if + * [decimalPlace] is positive, rounds off digits to the left of the decimal point if + * [decimalPlace] is negative. Rounds away from zero in halfway cases. + * + * ```kotlin + * // Round the value of the 'price' field to 2 decimal places. + * roundToPrecision(field("price"), 2) + * ``` + * + * @param numericExpr An expression that returns number when evaluated. + * @param decimalPlace The number of decimal places to round. + * @return A new [Expression] representing the round operation. + */ + +public com.google.firebase.firestore.pipeline.Expression roundToPrecision(com.google.firebase.firestore.pipeline.Expression numericExpr, int decimalPlace) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that rounds off [numericField] to [decimalPlace] decimal places if + * [decimalPlace] is positive, rounds off digits to the left of the decimal point if + * [decimalPlace] is negative. Rounds away from zero in halfway cases. + * + * ```kotlin + * // Round the value of the 'price' field to 2 decimal places. + * roundToPrecision("price", 2) + * ``` + * + * @param numericField Name of field that returns number when evaluated. + * @param decimalPlace The number of decimal places to round. + * @return A new [Expression] representing the round operation. + */ + +public com.google.firebase.firestore.pipeline.Expression roundToPrecision(java.lang.String numericField, int decimalPlace) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that rounds off [numericExpr] to [decimalPlace] decimal places if + * [decimalPlace] is positive, rounds off digits to the left of the decimal point if + * [decimalPlace] is negative. Rounds away from zero in halfway cases. + * + * ```kotlin + * // Round the value of the 'price' field to the number of decimal places specified in the + * // 'precision' field. + * roundToPrecision(field("price"), field("precision")) + * ``` + * + * @param numericExpr An expression that returns number when evaluated. + * @param decimalPlace The number of decimal places to round. + * @return A new [Expression] representing the round operation. + */ + +public com.google.firebase.firestore.pipeline.Expression roundToPrecision(com.google.firebase.firestore.pipeline.Expression numericExpr, com.google.firebase.firestore.pipeline.Expression decimalPlace) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that rounds off [numericField] to [decimalPlace] decimal places if + * [decimalPlace] is positive, rounds off digits to the left of the decimal point if + * [decimalPlace] is negative. Rounds away from zero in halfway cases. + * + * ```kotlin + * // Round the value of the 'price' field to the number of decimal places specified in the + * // 'precision' field. + * roundToPrecision("price", field("precision")) + * ``` + * + * @param numericField Name of field that returns number when evaluated. + * @param decimalPlace The number of decimal places to round. + * @return A new [Expression] representing the round operation. + */ + +public com.google.firebase.firestore.pipeline.Expression roundToPrecision(java.lang.String numericField, com.google.firebase.firestore.pipeline.Expression decimalPlace) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates [numericExpr] to an integer. + * + * ```kotlin + * // Truncate the value of the 'rating' field. + * trunc(field("rating")) + * ``` + * + * @param numericExpr An expression that returns number when evaluated. + * @return A new [Expression] representing the truncate operation. + */ + +public com.google.firebase.firestore.pipeline.Expression trunc(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates [numericField] to an integer. + * + * ```kotlin + * // Truncate the value of the 'rating' field. + * trunc("rating") + * ``` + * + * @param numericField Name of field that returns number when evaluated. + * @return A new [Expression] representing the truncate operation. + */ + +public com.google.firebase.firestore.pipeline.Expression trunc(java.lang.String numericField) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates [numericExpr] to [decimalPlace] decimal places if + * [decimalPlace] is positive, truncates digits to the left of the decimal point if + * [decimalPlace] is negative. + * + * ```kotlin + * // Truncate the value of the 'rating' field to 2 decimal places. + * truncToPrecision(field("rating"), 2) + * ``` + * + * @param numericExpr An expression that returns number when evaluated. + * @param decimalPlace The number of decimal places to truncate. + * @return A new [Expression] representing the truncate operation. + */ + +public com.google.firebase.firestore.pipeline.Expression truncToPrecision(com.google.firebase.firestore.pipeline.Expression numericExpr, int decimalPlace) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates [numericField] to [decimalPlace] decimal places if + * [decimalPlace] is positive, truncates digits to the left of the decimal point if + * [decimalPlace] is negative. + * + * ```kotlin + * // Truncate the value of the 'rating' field to 2 decimal places. + * truncToPrecision("rating", 2) + * ``` + * + * @param numericField Name of field that returns number when evaluated. + * @param decimalPlace The number of decimal places to truncate. + * @return A new [Expression] representing the truncate operation. + */ + +public com.google.firebase.firestore.pipeline.Expression truncToPrecision(java.lang.String numericField, int decimalPlace) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates [numericExpr] to [decimalPlace] decimal places if + * [decimalPlace] is positive, truncates digits to the left of the decimal point if + * [decimalPlace] is negative. + * + * ```kotlin + * // Truncate the value of the 'rating' field to the number of decimal places specified in the + * // 'precision' field. + * truncToPrecision(field("rating"), field("precision")) + * ``` + * + * @param numericExpr An expression that returns number when evaluated. + * @param decimalPlace The number of decimal places to truncate. + * @return A new [Expression] representing the truncate operation. + */ + +public com.google.firebase.firestore.pipeline.Expression truncToPrecision(com.google.firebase.firestore.pipeline.Expression numericExpr, com.google.firebase.firestore.pipeline.Expression decimalPlace) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates [numericField] to [decimalPlace] decimal places if + * [decimalPlace] is positive, truncates digits to the left of the decimal point if + * [decimalPlace] is negative. + * + * ```kotlin + * // Truncate the value of the 'rating' field to the number of decimal places specified in the + * // 'precision' field. + * truncToPrecision("rating", field("precision")) + * ``` + * + * @param numericField Name of field that returns number when evaluated. + * @param decimalPlace The number of decimal places to truncate. + * @return A new [Expression] representing the truncate operation. + */ + +public com.google.firebase.firestore.pipeline.Expression truncToPrecision(java.lang.String numericField, com.google.firebase.firestore.pipeline.Expression decimalPlace) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the smallest integer that isn't less than [numericExpr]. + * + * ```kotlin + * // Compute the ceiling of the 'price' field. + * ceil(field("price")) + * ``` + * + * @param numericExpr An expression that returns number when evaluated. + * @return A new [Expression] representing an integer result from the ceil operation. + */ + +public com.google.firebase.firestore.pipeline.Expression ceil(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the smallest integer that isn't less than [numericField]. + * + * ```kotlin + * // Compute the ceiling of the 'price' field. + * ceil("price") + * ``` + * + * @param numericField Name of field that returns number when evaluated. + * @return A new [Expression] representing an integer result from the ceil operation. + */ + +public com.google.firebase.firestore.pipeline.Expression ceil(java.lang.String numericField) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the largest integer that is not greater than [numericExpr] + * + * ```kotlin + * // Compute the floor of the 'price' field. + * floor(field("price")) + * ``` + * + * @param numericExpr An expression that returns number when evaluated. + * @return A new [Expression] representing an integer result from the floor operation. + */ + +public com.google.firebase.firestore.pipeline.Expression floor(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the largest integer that is not greater than + * [numericField]. + * + * ```kotlin + * // Compute the floor of the 'price' field. + * floor("price") + * ``` + * + * @param numericField Name of field that returns number when evaluated. + * @return A new [Expression] representing an integer result from the floor operation. + */ + +public com.google.firebase.firestore.pipeline.Expression floor(java.lang.String numericField) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [numericExpr] raised to the power of the [exponent]. + * Returns infinity on overflow and zero on underflow. + * + * ```kotlin + * // Raise the value of the 'base' field to the power of 2. + * pow(field("base"), 2) + * ``` + * + * @param numericExpr An expression that returns number when evaluated. + * @param exponent The numeric power to raise the [numericExpr]. + * @return A new [Expression] representing a numeric result from raising [numericExpr] to the + * power of [exponent]. + */ + +public com.google.firebase.firestore.pipeline.Expression pow(com.google.firebase.firestore.pipeline.Expression numericExpr, java.lang.Number exponent) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [numericField] raised to the power of the [exponent]. + * Returns infinity on overflow and zero on underflow. + * + * ```kotlin + * // Raise the value of the 'base' field to the power of 2. + * pow("base", 2) + * ``` + * + * @param numericField Name of field that returns number when evaluated. + * @param exponent The numeric power to raise the [numericField]. + * @return A new [Expression] representing a numeric result from raising [numericField] to the + * power of [exponent]. + */ + +public com.google.firebase.firestore.pipeline.Expression pow(java.lang.String numericField, java.lang.Number exponent) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [numericExpr] raised to the power of the [exponent]. + * Returns infinity on overflow and zero on underflow. + * + * ```kotlin + * // Raise the value of the 'base' field to the power of the 'exponent' field. + * pow(field("base"), field("exponent")) + * ``` + * + * @param numericExpr An expression that returns number when evaluated. + * @param exponent The numeric power to raise the [numericExpr]. + * @return A new [Expression] representing a numeric result from raising [numericExpr] to the + * power of [exponent]. + */ + +public com.google.firebase.firestore.pipeline.Expression pow(com.google.firebase.firestore.pipeline.Expression numericExpr, com.google.firebase.firestore.pipeline.Expression exponent) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [numericField] raised to the power of the [exponent]. + * Returns infinity on overflow and zero on underflow. + * + * ```kotlin + * // Raise the value of the 'base' field to the power of the 'exponent' field. + * pow("base", field("exponent")) + * ``` + * + * @param numericField Name of field that returns number when evaluated. + * @param exponent The numeric power to raise the [numericField]. + * @return A new [Expression] representing a numeric result from raising [numericField] to the + * power of [exponent]. + */ + +public com.google.firebase.firestore.pipeline.Expression pow(java.lang.String numericField, com.google.firebase.firestore.pipeline.Expression exponent) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the absolute value of [numericExpr]. + * + * ```kotlin + * // Get the absolute value of the 'change' field. + * abs(field("change")) + * ``` + * + * @param numericExpr An expression that returns number when evaluated. + * @return A new [Expression] representing the numeric result of the absolute value operation. + */ + +public com.google.firebase.firestore.pipeline.Expression abs(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the absolute value of [numericField]. + * + * ```kotlin + * // Get the absolute value of the 'change' field. + * abs("change") + * ``` + * + * @param numericField Name of field that returns number when evaluated. + * @return A new [Expression] representing the numeric result of the absolute value operation. + */ + +public com.google.firebase.firestore.pipeline.Expression abs(java.lang.String numericField) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns Euler's number e raised to the power of [numericExpr]. + * + * ```kotlin + * // Compute e to the power of the 'value' field. + * exp(field("value")) + * ``` + * + * @param numericExpr An expression that returns number when evaluated. + * @return A new [Expression] representing the numeric result of the exponentiation. + */ + +public com.google.firebase.firestore.pipeline.Expression exp(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns Euler's number e raised to the power of [numericField]. + * + * ```kotlin + * // Compute e to the power of the 'value' field. + * exp("value") + * ``` + * + * @param numericField Name of field that returns number when evaluated. + * @return A new [Expression] representing the numeric result of the exponentiation. + */ + +public com.google.firebase.firestore.pipeline.Expression exp(java.lang.String numericField) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the natural logarithm (base e) of [numericExpr]. + * + * ```kotlin + * // Compute the natural logarithm of the 'value' field. + * ln(field("value")) + * ``` + * + * @param numericExpr An expression that returns number when evaluated. + * @return A new [Expression] representing the numeric result of the natural logarithm. + */ + +public com.google.firebase.firestore.pipeline.Expression ln(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the natural logarithm (base e) of [numericField]. + * + * ```kotlin + * // Compute the natural logarithm of the 'value' field. + * ln("value") + * ``` + * + * @param numericField Name of field that returns number when evaluated. + * @return A new [Expression] representing the numeric result of the natural logarithm. + */ + +public com.google.firebase.firestore.pipeline.Expression ln(java.lang.String numericField) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the logarithm of [numericExpr] with a given [base]. + * + * ```kotlin + * // Compute the logarithm of the 'value' field with base 10. + * log(field("value"), 10) + * ``` + * + * @param numericExpr An expression that returns number when evaluated. + * @param base The base of the logarithm. + * @return A new [Expression] representing a numeric result from the logarithm of [numericExpr] + * with a given [base]. + */ + +public com.google.firebase.firestore.pipeline.Expression log(com.google.firebase.firestore.pipeline.Expression numericExpr, java.lang.Number base) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the logarithm of [numericField] with a given [base]. + * + * ```kotlin + * // Compute the logarithm of the 'value' field with base 10. + * log("value", 10) + * ``` + * + * @param numericField Name of field that returns number when evaluated. + * @param base The base of the logarithm. + * @return A new [Expression] representing a numeric result from the logarithm of [numericField] + * with a given [base]. + */ + +public com.google.firebase.firestore.pipeline.Expression log(java.lang.String numericField, java.lang.Number base) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the logarithm of [numericExpr] with a given [base]. + * + * ```kotlin + * // Compute the logarithm of the 'value' field with the base in the 'base' field. + * log(field("value"), field("base")) + * ``` + * + * @param numericExpr An expression that returns number when evaluated. + * @param base The base of the logarithm. + * @return A new [Expression] representing a numeric result from the logarithm of [numericExpr] + * with a given [base]. + */ + +public com.google.firebase.firestore.pipeline.Expression log(com.google.firebase.firestore.pipeline.Expression numericExpr, com.google.firebase.firestore.pipeline.Expression base) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the logarithm of [numericField] with a given [base]. + * + * ```kotlin + * // Compute the logarithm of the 'value' field with the base in the 'base' field. + * log("value", field("base")) + * ``` + * + * @param numericField Name of field that returns number when evaluated. + * @param base The base of the logarithm. + * @return A new [Expression] representing a numeric result from the logarithm of [numericField] + * with a given [base]. + */ + +public com.google.firebase.firestore.pipeline.Expression log(java.lang.String numericField, com.google.firebase.firestore.pipeline.Expression base) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the base 10 logarithm of [numericExpr]. + * + * ```kotlin + * // Compute the base 10 logarithm of the 'value' field. + * log10(field("value")) + * ``` + * + * @param numericExpr An expression that returns number when evaluated. + * @return A new [Expression] representing the numeric result of the base 10 logarithm. + */ + +public com.google.firebase.firestore.pipeline.Expression log10(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the base 10 logarithm of [numericField]. + * + * ```kotlin + * // Compute the base 10 logarithm of the 'value' field. + * log10("value") + * ``` + * + * @param numericField Name of field that returns number when evaluated. + * @return A new [Expression] representing the numeric result of the base 10 logarithm. + */ + +public com.google.firebase.firestore.pipeline.Expression log10(java.lang.String numericField) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the square root of [numericExpr]. + * + * ```kotlin + * // Compute the square root of the 'value' field. + * sqrt(field("value")) + * ``` + * + * @param numericExpr An expression that returns number when evaluated. + * @return A new [Expression] representing the numeric result of the square root operation. + */ + +public com.google.firebase.firestore.pipeline.Expression sqrt(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the square root of [numericField]. + * + * ```kotlin + * // Compute the square root of the 'value' field. + * sqrt("value") + * ``` + * + * @param numericField Name of field that returns number when evaluated. + * @return A new [Expression] representing the numeric result of the square root operation. + */ + +public com.google.firebase.firestore.pipeline.Expression sqrt(java.lang.String numericField) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that adds numeric expressions. + * + * ```kotlin + * // Add the value of the 'quantity' field and the 'reserve' field. + * add(field("quantity"), field("reserve")) + * ``` + * + * @param first Numeric expression to add. + * @param second Numeric expression to add. + * @return A new [Expression] representing the addition operation. + */ + +public com.google.firebase.firestore.pipeline.Expression add(com.google.firebase.firestore.pipeline.Expression first, com.google.firebase.firestore.pipeline.Expression second) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that adds numeric expressions with a constant. + * + * ```kotlin + * // Add 5 to the value of the 'quantity' field. + * add(field("quantity"), 5) + * ``` + * + * @param first Numeric expression to add. + * @param second Constant to add. + * @return A new [Expression] representing the addition operation. + */ + +public com.google.firebase.firestore.pipeline.Expression add(com.google.firebase.firestore.pipeline.Expression first, java.lang.Number second) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that adds a numeric field with a numeric expression. + * + * ```kotlin + * // Add the value of the 'quantity' field and the 'reserve' field. + * add("quantity", field("reserve")) + * ``` + * + * @param numericFieldName Numeric field to add. + * @param second Numeric expression to add to field value. + * @return A new [Expression] representing the addition operation. + */ + +public com.google.firebase.firestore.pipeline.Expression add(java.lang.String numericFieldName, com.google.firebase.firestore.pipeline.Expression second) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that adds a numeric field with constant. + * + * ```kotlin + * // Add 5 to the value of the 'quantity' field. + * add("quantity", 5) + * ``` + * + * @param numericFieldName Numeric field to add. + * @param second Constant to add. + * @return A new [Expression] representing the addition operation. + */ + +public com.google.firebase.firestore.pipeline.Expression add(java.lang.String numericFieldName, java.lang.Number second) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that subtracts two expressions. + * + * ```kotlin + * // Subtract the 'discount' field from the 'price' field + * subtract(field("price"), field("discount")) + * ``` + * + * @param minuend Numeric expression to subtract from. + * @param subtrahend Numeric expression to subtract. + * @return A new [Expression] representing the subtract operation. + */ + +public com.google.firebase.firestore.pipeline.Expression subtract(com.google.firebase.firestore.pipeline.Expression minuend, com.google.firebase.firestore.pipeline.Expression subtrahend) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that subtracts a constant value from a numeric expression. + * + * ```kotlin + * // Subtract 10 from the 'price' field. + * subtract(field("price"), 10) + * ``` + * + * @param minuend Numeric expression to subtract from. + * @param subtrahend Constant to subtract. + * @return A new [Expression] representing the subtract operation. + */ + +public com.google.firebase.firestore.pipeline.Expression subtract(com.google.firebase.firestore.pipeline.Expression minuend, java.lang.Number subtrahend) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that subtracts a numeric expressions from numeric field. + * + * ```kotlin + * // Subtract the 'discount' field from the 'price' field. + * subtract("price", field("discount")) + * ``` + * + * @param numericFieldName Numeric field to subtract from. + * @param subtrahend Numeric expression to subtract. + * @return A new [Expression] representing the subtract operation. + */ + +public com.google.firebase.firestore.pipeline.Expression subtract(java.lang.String numericFieldName, com.google.firebase.firestore.pipeline.Expression subtrahend) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that subtracts a constant from numeric field. + * + * ```kotlin + * // Subtract 10 from the 'price' field. + * subtract("price", 10) + * ``` + * + * @param numericFieldName Numeric field to subtract from. + * @param subtrahend Constant to subtract. + * @return A new [Expression] representing the subtract operation. + */ + +public com.google.firebase.firestore.pipeline.Expression subtract(java.lang.String numericFieldName, java.lang.Number subtrahend) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that multiplies numeric expressions. + * + * ```kotlin + * // Multiply the 'quantity' field by the 'price' field + * multiply(field("quantity"), field("price")) + * ``` + * + * @param first Numeric expression to multiply. + * @param second Numeric expression to multiply. + * @return A new [Expression] representing the multiplication operation. + */ + +public com.google.firebase.firestore.pipeline.Expression multiply(com.google.firebase.firestore.pipeline.Expression first, com.google.firebase.firestore.pipeline.Expression second) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that multiplies numeric expressions with a constant. + * + * ```kotlin + * // Multiply the 'quantity' field by 1.1. + * multiply(field("quantity"), 1.1) + * ``` + * + * @param first Numeric expression to multiply. + * @param second Constant to multiply. + * @return A new [Expression] representing the multiplication operation. + */ + +public com.google.firebase.firestore.pipeline.Expression multiply(com.google.firebase.firestore.pipeline.Expression first, java.lang.Number second) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that multiplies a numeric field with a numeric expression. + * + * ```kotlin + * // Multiply the 'quantity' field by the 'price' field. + * multiply("quantity", field("price")) + * ``` + * + * @param numericFieldName Numeric field to multiply. + * @param second Numeric expression to multiply. + * @return A new [Expression] representing the multiplication operation. + */ + +public com.google.firebase.firestore.pipeline.Expression multiply(java.lang.String numericFieldName, com.google.firebase.firestore.pipeline.Expression second) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that multiplies a numeric field with a constant. + * + * ```kotlin + * // Multiply the 'quantity' field by 1.1. + * multiply("quantity", 1.1) + * ``` + * + * @param numericFieldName Numeric field to multiply. + * @param second Constant to multiply. + * @return A new [Expression] representing the multiplication operation. + */ + +public com.google.firebase.firestore.pipeline.Expression multiply(java.lang.String numericFieldName, java.lang.Number second) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that divides two numeric expressions. + * + * ```kotlin + * // Divide the 'total' field by the 'count' field + * divide(field("total"), field("count")) + * ``` + * + * @param dividend The numeric expression to be divided. + * @param divisor The numeric expression to divide by. + * @return A new [Expression] representing the division operation. + */ + +public com.google.firebase.firestore.pipeline.Expression divide(com.google.firebase.firestore.pipeline.Expression dividend, com.google.firebase.firestore.pipeline.Expression divisor) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that divides a numeric expression by a constant. + * + * ```kotlin + * // Divide the 'value' field by 10 + * divide(field("value"), 10) + * ``` + * + * @param dividend The numeric expression to be divided. + * @param divisor The constant to divide by. + * @return A new [Expression] representing the division operation. + */ + +public com.google.firebase.firestore.pipeline.Expression divide(com.google.firebase.firestore.pipeline.Expression dividend, java.lang.Number divisor) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that divides numeric field by a numeric expression. + * + * ```kotlin + * // Divide the 'total' field by the 'count' field. + * divide("total", field("count")) + * ``` + * + * @param dividendFieldName The numeric field name to be divided. + * @param divisor The numeric expression to divide by. + * @return A new [Expression] representing the divide operation. + */ + +public com.google.firebase.firestore.pipeline.Expression divide(java.lang.String dividendFieldName, com.google.firebase.firestore.pipeline.Expression divisor) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that divides a numeric field by a constant. + * + * ```kotlin + * // Divide the 'total' field by 2. + * divide("total", 2) + * ``` + * + * @param dividendFieldName The numeric field name to be divided. + * @param divisor The constant to divide by. + * @return A new [Expression] representing the divide operation. + */ + +public com.google.firebase.firestore.pipeline.Expression divide(java.lang.String dividendFieldName, java.lang.Number divisor) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the modulo (remainder) of dividing two numeric + * expressions. + * + * ```kotlin + * // Calculate the remainder of dividing the 'value' field by the 'divisor' field + * mod(field("value"), field("divisor")) + * ``` + * + * @param dividend The numeric expression to be divided. + * @param divisor The numeric expression to divide by. + * @return A new [Expression] representing the modulo operation. + */ + +public com.google.firebase.firestore.pipeline.Expression mod(com.google.firebase.firestore.pipeline.Expression dividend, com.google.firebase.firestore.pipeline.Expression divisor) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the modulo (remainder) of dividing a numeric expression + * by a constant. + * + * ```kotlin + * // Calculate the remainder of dividing the 'value' field by 3. + * mod(field("value"), 3) + * ``` + * + * @param dividend The numeric expression to be divided. + * @param divisor The constant to divide by. + * @return A new [Expression] representing the modulo operation. + */ + +public com.google.firebase.firestore.pipeline.Expression mod(com.google.firebase.firestore.pipeline.Expression dividend, java.lang.Number divisor) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the modulo (remainder) of dividing a numeric field by a + * constant. + * + * ```kotlin + * // Calculate the remainder of dividing the 'value' field by the 'divisor' field. + * mod("value", field("divisor")) + * ``` + * + * @param dividendFieldName The numeric field name to be divided. + * @param divisor The numeric expression to divide by. + * @return A new [Expression] representing the modulo operation. + */ + +public com.google.firebase.firestore.pipeline.Expression mod(java.lang.String dividendFieldName, com.google.firebase.firestore.pipeline.Expression divisor) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the modulo (remainder) of dividing a numeric field by a + * constant. + * + * ```kotlin + * // Calculate the remainder of dividing the 'value' field by 3. + * mod("value", 3) + * ``` + * + * @param dividendFieldName The numeric field name to be divided. + * @param divisor The constant to divide by. + * @return A new [Expression] representing the modulo operation. + */ + +public com.google.firebase.firestore.pipeline.Expression mod(java.lang.String dividendFieldName, java.lang.Number divisor) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if an [expression], when evaluated, is equal to any of the + * provided [values]. + * + * ```kotlin + * // Check if the 'category' field is either "Electronics" or the value of the 'primaryType' field. + * equalAny(field("category"), listOf("Electronics", field("primaryType"))) + * ``` + * + * @param expression The expression whose results to compare. + * @param values The values to check against. + * @return A new [BooleanExpression] representing the 'IN' comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression equalAny(com.google.firebase.firestore.pipeline.Expression expression, java.util.List values) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if an [expression], when evaluated, is equal to any of the + * elements of [arrayExpression]. + * + * ```kotlin + * // Check if the 'category' field is in the 'availableCategories' array field. + * equalAny(field("category"), field("availableCategories")) + * ``` + * + * @param expression The expression whose results to compare. + * @param arrayExpression An expression that evaluates to an array, whose elements to check for + * equality to the input. + * @return A new [BooleanExpression] representing the 'IN' comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression equalAny(com.google.firebase.firestore.pipeline.Expression expression, com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field's value is equal to any of the provided [values] + * . + * + * ```kotlin + * // Check if the 'category' field is either "Electronics" or "Apparel". + * equalAny("category", listOf("Electronics", "Apparel")) + * ``` + * + * @param fieldName The field to compare. + * @param values The values to check against. + * @return A new [BooleanExpression] representing the 'IN' comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression equalAny(java.lang.String fieldName, java.util.List values) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field's value is equal to any of the elements of + * [arrayExpression]. + * + * ```kotlin + * // Check if the 'category' field is in the 'availableCategories' array field. + * equalAny("category", field("availableCategories")) + * ``` + * + * @param fieldName The field to compare. + * @param arrayExpression An expression that evaluates to an array, whose elements to check for + * equality to the input. + * @return A new [BooleanExpression] representing the 'IN' comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression equalAny(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if an [expression], when evaluated, is not equal to all the + * provided [values]. + * + * ```kotlin + * // Check if the 'status' field is neither "pending" nor the value of the 'rejectedStatus' field. + * notEqualAny(field("status"), listOf("pending", field("rejectedStatus"))) + * ``` + * + * @param expression The expression whose results to compare. + * @param values The values to check against. + * @return A new [BooleanExpression] representing the 'NOT IN' comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression notEqualAny(com.google.firebase.firestore.pipeline.Expression expression, java.util.List values) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if an [expression], when evaluated, is not equal to all the + * elements of [arrayExpression]. + * + * ```kotlin + * // Check if the 'status' field is not in the 'inactiveStatuses' array field. + * notEqualAny(field("status"), field("inactiveStatuses")) + * ``` + * + * @param expression The expression whose results to compare. + * @param arrayExpression An expression that evaluates to an array, whose elements to check for + * equality to the input. + * @return A new [BooleanExpression] representing the 'NOT IN' comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression notEqualAny(com.google.firebase.firestore.pipeline.Expression expression, com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field's value is not equal to all of the provided + * [values]. + * + * ```kotlin + * // Check if the 'status' field is not "archived" or "deleted". + * notEqualAny("status", listOf("archived", "deleted")) + * ``` + * + * @param fieldName The field to compare. + * @param values The values to check against. + * @return A new [BooleanExpression] representing the 'NOT IN' comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression notEqualAny(java.lang.String fieldName, java.util.List values) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field's value is not equal to all of the elements of + * [arrayExpression]. + * + * ```kotlin + * // Check if the 'status' field is not in the 'inactiveStatuses' array field. + * notEqualAny("status", field("inactiveStatuses")) + * ``` + * + * @param fieldName The field to compare. + * @param arrayExpression An expression that evaluates to an array, whose elements to check for + * equality to the input. + * @return A new [BooleanExpression] representing the 'NOT IN' comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression notEqualAny(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns true if a value is absent. Otherwise, returns false even + * if the value is null. + * + * ```kotlin + * // Check if the field `value` is absent. + * isAbsent(field("value")) + * ``` + * + * @param value The expression to check. + * @return A new [BooleanExpression] representing the isAbsent operation. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression isAbsent(com.google.firebase.firestore.pipeline.Expression value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns true if a field is absent. Otherwise, returns false even + * if the field value is null. + * + * ```kotlin + * // Check if the field `value` is absent. + * isAbsent("value") + * ``` + * + * @param fieldName The field to check. + * @return A new [BooleanExpression] representing the isAbsent operation. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression isAbsent(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a string indicating the type of the value this expression + * evaluates to. + * + * ```kotlin + * // Get the type of the 'value' field. + * type(field("value")) + * ``` + * + * @param expr The expression to get the type of. + * @return A new [Expression] representing the type operation. + */ + +public com.google.firebase.firestore.pipeline.Expression type(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a string indicating the type of the value this field + * evaluates to. + * + * ```kotlin + * // Get the type of the 'field' field. + * type("field") + * ``` + * + * @param fieldName The name of the field to get the type of. + * @return A new [Expression] representing the type operation. + */ + +public com.google.firebase.firestore.pipeline.Expression type(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if the result of an expression is of the given type. + * + * Supported values for `type` are: "null", "array", "boolean", "bytes", "timestamp", + * "geo_point", "number", "int32", "int64", "float64", "decimal128", "map", "reference", + * "string", "vector", "max_key", "min_key", "object_id", "regex", and "request_timestamp". + * + * ```kotlin + * // Check if the 'age' field is an integer + * isType(field("age"), "int64") + * ``` + * + * @param expr The expression to check the type of. + * @param type The type to check for. + * @return A new [BooleanExpression] that evaluates to true if the expression's result is of the + * given type, false otherwise. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression isType(com.google.firebase.firestore.pipeline.Expression expr, java.lang.String type) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if the value of a field is of the given type. + * + * Supported values for `type` are: "null", "array", "boolean", "bytes", "timestamp", + * "geo_point", "number", "int32", "int64", "float64", "decimal128", "map", "reference", + * "string", "vector", "max_key", "min_key", "object_id", "regex", and "request_timestamp". + * + * ```kotlin + * // Check if the 'age' field is an integer + * isType("age", "int64") + * ``` + * + * @param fieldName The name of the field to check the type of. + * @param type The type to check for. + * @return A new [BooleanExpression] that evaluates to true if the expression's result is of the + * given type, false otherwise. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression isType(java.lang.String fieldName, java.lang.String type) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the length of a string, array, map, vector, or blob + * expression. + * + * ```kotlin + * // Get the length of the 'value' field where the value type can be any of a string, array, map, vector or blob. + * length(field("value")) + * ``` + * + * @param expr The expression representing the string. + * @return A new [Expression] representing the length operation. + */ + +public com.google.firebase.firestore.pipeline.Expression length(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the length of a string, array, map, vector, or blob + * field. + * + * ```kotlin + * // Get the length of the 'value' field where the value type can be any of a string, array, map, vector or blob. + * charLength("value") + * ``` + * + * @param fieldName The name of the field containing the string. + * @return A new [Expression] representing the length operation. + */ + +public com.google.firebase.firestore.pipeline.Expression length(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the character length of a string expression in UTF8. + * + * ```kotlin + * // Get the character length of the 'name' field in UTF-8. + * charLength("name") + * ``` + * + * @param expr The expression representing the string. + * @return A new [Expression] representing the charLength operation. + */ + +public com.google.firebase.firestore.pipeline.Expression charLength(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the character length of a string field in UTF8. + * + * ```kotlin + * // Get the character length of the 'name' field in UTF-8. + * charLength("name") + * ``` + * + * @param fieldName The name of the field containing the string. + * @return A new [Expression] representing the charLength operation. + */ + +public com.google.firebase.firestore.pipeline.Expression charLength(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the length of a string in UTF-8 bytes, or just the + * length of a Blob. + * + * ```kotlin + * // Calculate the length of the 'myString' field in bytes. + * byteLength("myString") + * ``` + * + * @param value The expression representing the string. + * @return A new [Expression] representing the length of the string in bytes. + */ + +public com.google.firebase.firestore.pipeline.Expression byteLength(com.google.firebase.firestore.pipeline.Expression value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the length of a string represented by a field in UTF-8 + * bytes, or just the length of a Blob. + * + * ```kotlin + * // Calculate the length of the 'myString' field in bytes. + * byteLength("myString") + * ``` + * + * @param fieldName The name of the field containing the string. + * @return A new [Expression] representing the length of the string in bytes. + */ + +public com.google.firebase.firestore.pipeline.Expression byteLength(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that performs a case-sensitive wildcard string comparison. + * + * ```kotlin + * // Check if the 'title' field contains the string "guide" + * like(field("title"), "%guide%") + * ``` + * + * @param stringExpression The expression representing the string to perform the comparison on. + * @param pattern The pattern to search for. You can use "%" as a wildcard character. + * @return A new [BooleanExpression] representing the like operation. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression like(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that splits a string or blob by a delimiter. + * + * ```kotlin + * // Split the 'tags' field by a comma + * split(field("tags"), field("delimiter")) + * ``` + * + * @param value The expression evaluating to a string or blob to be split. + * @param delimiter The delimiter to split by. Must be of the same type as `value`. + * @return A new [Expression] that evaluates to an array of segments. + */ + +public com.google.firebase.firestore.pipeline.Expression split(com.google.firebase.firestore.pipeline.Expression value, com.google.firebase.firestore.pipeline.Expression delimiter) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that splits a string or blob by a string delimiter. + * + * ```kotlin + * // Split the 'tags' field by a comma + * split(field("tags"), ",") + * ``` + * + * @param value The expression evaluating to a string or blob to be split. + * @param delimiter The string delimiter to split by. + * @return A new [Expression] that evaluates to an array of segments. + */ + +public com.google.firebase.firestore.pipeline.Expression split(com.google.firebase.firestore.pipeline.Expression value, java.lang.String delimiter) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that splits a blob by a blob delimiter. + * + * ```kotlin + * // Split the 'data' field by a delimiter + * split(field("data"), Blob.fromBytes(byteArrayOf(0x0a))) + * ``` + * + * @param value The expression evaluating to a blob to be split. + * @param delimiter The blob delimiter to split by. + * @return A new [Expression] that evaluates to an array of segments. + */ + +public com.google.firebase.firestore.pipeline.Expression split(com.google.firebase.firestore.pipeline.Expression value, com.google.firebase.firestore.Blob delimiter) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that splits a string or blob field by a delimiter. + * + * ```kotlin + * // Split the 'tags' field by the value of the 'delimiter' field + * split("tags", field("delimiter")) + * ``` + * + * @param fieldName The name of the field containing the string or blob to be split. + * @param delimiter The delimiter to split by. + * @return A new [Expression] that evaluates to an array of segments. + */ + +public com.google.firebase.firestore.pipeline.Expression split(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression delimiter) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that splits a string or blob field by a string delimiter. + * + * ```kotlin + * // Split the 'tags' field by a comma + * split("tags", ",") + * ``` + * + * @param fieldName The name of the field containing the string or blob to be split. + * @param delimiter The string delimiter to split by. + * @return A new [Expression] that evaluates to an array of segments. + */ + +public com.google.firebase.firestore.pipeline.Expression split(java.lang.String fieldName, java.lang.String delimiter) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that splits a blob field by a blob delimiter. + * + * ```kotlin + * // Split the 'data' field by a delimiter + * split("data", Blob.fromBytes(byteArrayOf(0x0a))) + * ``` + * + * @param fieldName The name of the field containing the blob to be split. + * @param delimiter The blob delimiter to split by. + * @return A new [Expression] that evaluates to an array of segments. + */ + +public com.google.firebase.firestore.pipeline.Expression split(java.lang.String fieldName, com.google.firebase.firestore.Blob delimiter) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that joins the elements of an array into a string. + * + * ```kotlin + * // Join the elements of the 'tags' field with a comma and space. + * join(field("tags"), ", ") + * ``` + * + * @param arrayExpression The expression that evaluates to an array. + * @param delimiter The string to use as a delimiter. + * @return A new [Expression] representing the join operation. + */ + +public com.google.firebase.firestore.pipeline.Expression join(com.google.firebase.firestore.pipeline.Expression arrayExpression, java.lang.String delimiter) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that joins the elements of an array into a string. + * + * ```kotlin + * // Join the elements of the 'tags' field with the delimiter from the 'separator' field. + * join(field("tags"), field("separator")) + * ``` + * + * @param arrayExpression The expression that evaluates to an array. + * @param delimiterExpression The expression that evaluates to the delimiter string. + * @return A new [Expression] representing the join operation. + */ + +public com.google.firebase.firestore.pipeline.Expression join(com.google.firebase.firestore.pipeline.Expression arrayExpression, com.google.firebase.firestore.pipeline.Expression delimiterExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that joins the elements of an array field into a string. + * + * ```kotlin + * // Join the elements of the 'tags' field with a comma and space. + * join("tags", ", ") + * ``` + * + * @param arrayFieldName The name of the field containing the array. + * @param delimiter The string to use as a delimiter. + * @return A new [Expression] representing the join operation. + */ + +public com.google.firebase.firestore.pipeline.Expression join(java.lang.String arrayFieldName, java.lang.String delimiter) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that joins the elements of an array field into a string. + * + * ```kotlin + * // Join the elements of the 'tags' field with the delimiter from the 'separator' field. + * join("tags", field("separator")) + * ``` + * + * @param arrayFieldName The name of the field containing the array. + * @param delimiterExpression The expression that evaluates to the delimiter string. + * @return A new [Expression] representing the join operation. + */ + +public com.google.firebase.firestore.pipeline.Expression join(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression delimiterExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that performs a case-sensitive wildcard string comparison. + * + * ```kotlin + * // Check if the 'title' field contains the string "guide" + * like(field("title"), "%guide%") + * ``` + * + * @param stringExpression The expression representing the string to perform the comparison on. + * @param pattern The pattern to search for. You can use "%" as a wildcard character. + * @return A new [BooleanExpression] representing the like operation. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression like(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that performs a case-sensitive wildcard string comparison against a + * field. + * + * ```kotlin + * // Check if the 'title' field contains the string "guide" + * like("title", "%guide%") + * ``` + * + * @param fieldName The name of the field containing the string. + * @param pattern The pattern to search for. You can use "%" as a wildcard character. + * @return A new [BooleanExpression] representing the like comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression like(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that performs a case-sensitive wildcard string comparison against a + * field. + * + * ```kotlin + * // Check if the 'title' field contains the string "guide" + * like("title", "%guide%") + * ``` + * + * @param fieldName The name of the field containing the string. + * @param pattern The pattern to search for. You can use "%" as a wildcard character. + * @return A new [BooleanExpression] representing the like comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression like(java.lang.String fieldName, java.lang.String pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a pseudo-random number of type double in the range of [0, + * 1), inclusive of 0 and exclusive of 1. + * + * ```kotlin + * // Get a random number. + * rand() + * ``` + * + * @return A new [Expression] representing the random number operation. + */ + +public com.google.firebase.firestore.pipeline.Expression rand() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string expression contains a specified regular + * expression as a substring. + * + * ```kotlin + * // Check if the 'description' field contains "example" (case-insensitive) + * regexContains(field("description"), "(?i)example") + * ``` + * + * @param stringExpression The expression representing the string to perform the comparison on. + * @param pattern The regular expression to use for the search. + * @return A new [BooleanExpression] representing the contains regular expression comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression regexContains(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string expression contains a specified regular + * expression as a substring. + * + * ```kotlin + * // Check if the 'description' field contains "example" (case-insensitive) + * regexContains(field("description"), "(?i)example") + * ``` + * + * @param stringExpression The expression representing the string to perform the comparison on. + * @param pattern The regular expression to use for the search. + * @return A new [BooleanExpression] representing the contains regular expression comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression regexContains(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string field contains a specified regular expression + * as a substring. + * + * ```kotlin + * // Check if the 'description' field contains the regex from the 'pattern' field. + * regexContains("description", field("pattern")) + * ``` + * + * @param fieldName The name of the field containing the string. + * @param pattern The regular expression to use for the search. + * @return A new [BooleanExpression] representing the contains regular expression comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression regexContains(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string field contains a specified regular expression + * as a substring. + * + * ```kotlin + * // Check if the 'description' field contains "example" (case-insensitive) + * regexContains("description", "(?i)example") + * ``` + * + * @param fieldName The name of the field containing the string. + * @param pattern The regular expression to use for the search. + * @return A new [BooleanExpression] representing the contains regular expression comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression regexContains(java.lang.String fieldName, java.lang.String pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first substring of a string expression that matches a + * specified regular expression. + * + * This expression uses the [RE2](https://github.com/google/re2/wiki/Syntax) regular expression + * syntax. + * + * ```kotlin + * // Extract a substring based on a dynamic pattern field + * regexFind(field("email"), field("pattern")) + * ``` + * + * @param stringExpression The expression representing the string to search. + * @param pattern The regular expression to search for. + * @return A new [Expression] representing the regular expression find function. + */ + +public com.google.firebase.firestore.pipeline.Expression regexFind(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first substring of a string expression that matches a + * specified regular expression. + * + * This expression uses the [RE2](https://github.com/google/re2/wiki/Syntax) regular expression + * syntax. + * + * ```kotlin + * // Extract the domain from a lower-cased email address + * regexFind(field("email"), "@[A-Za-z0-9.-]+") + * ``` + * + * @param stringExpression The expression representing the string to search. + * @param pattern The regular expression to search for. + * @return A new [Expression] representing the regular expression find function. + */ + +public com.google.firebase.firestore.pipeline.Expression regexFind(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first substring of a string field that matches a + * specified regular expression. + * + * This expression uses the [RE2](https://github.com/google/re2/wiki/Syntax) regular expression + * syntax. + * + * ```kotlin + * // Extract a substring from 'email' based on a pattern stored in another field + * regexFind("email", field("pattern")) + * ``` + * + * @param fieldName The name of the field containing the string to search. + * @param pattern The regular expression to search for. + * @return A new [Expression] representing the regular expression find function. + */ + +public com.google.firebase.firestore.pipeline.Expression regexFind(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first substring of a string field that matches a + * specified regular expression. + * + * This expression uses the [RE2](https://github.com/google/re2/wiki/Syntax) regular expression + * syntax. + * + * ```kotlin + * // Extract the domain name from an email field + * regexFind("email", "@[A-Za-z0-9.-]+") + * ``` + * + * @param fieldName The name of the field containing the string to search. + * @param pattern The regular expression to search for. + * @return A new [Expression] representing the regular expression find function. + */ + +public com.google.firebase.firestore.pipeline.Expression regexFind(java.lang.String fieldName, java.lang.String pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that evaluates to a list of all substrings in a string expression that + * match a specified regular expression. + * + * This expression uses the [RE2](https://github.com/google/re2/wiki/Syntax) regular expression + * syntax. + * + * ```kotlin + * // Extract all matches based on a dynamic pattern expression + * regexFindAll(field("comment"), field("pattern")) + * ``` + * + * @param stringExpression The expression representing the string to search. + * @param pattern The regular expression to search for. + * @return A new [Expression] that evaluates to a list of matched substrings. + */ + +public com.google.firebase.firestore.pipeline.Expression regexFindAll(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that evaluates to a list of all substrings in a string expression that + * match a specified regular expression. + * + * This expression uses the [RE2](https://github.com/google/re2/wiki/Syntax) regular expression + * syntax. + * + * ```kotlin + * // Extract all mentions from a lower-cased comment + * regexFindAll(field("comment"), "@[A-Za-z0-9_]+") + * ``` + * + * @param stringExpression The expression representing the string to search. + * @param pattern The regular expression to search for. + * @return A new [Expression] that evaluates to a list of matched substrings. + */ + +public com.google.firebase.firestore.pipeline.Expression regexFindAll(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that evaluates to a list of all substrings in a string field that match + * a specified regular expression. + * + * This expression uses the [RE2](https://github.com/google/re2/wiki/Syntax) regular expression + * syntax. + * + * ```kotlin + * // Extract all matches from 'content' based on a pattern stored in another field + * regexFindAll("content", field("pattern")) + * ``` + * + * @param fieldName The name of the field containing the string to search. + * @param pattern The regular expression to search for. + * @return A new [Expression] that evaluates to a list of matched substrings. + */ + +public com.google.firebase.firestore.pipeline.Expression regexFindAll(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that evaluates to a list of all substrings in a string field that match + * a specified regular expression. + * + * This expression uses the [RE2](https://github.com/google/re2/wiki/Syntax) regular expression + * syntax. + * + * ```kotlin + * // Extract all hashtags from a post content field + * regexFindAll("content", "#[A-Za-z0-9_]+") + * ``` + * + * @param fieldName The name of the field containing the string to search. + * @param pattern The regular expression to search for. + * @return A new [Expression] that evaluates to a list of matched substrings. + */ + +public com.google.firebase.firestore.pipeline.Expression regexFindAll(java.lang.String fieldName, java.lang.String pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string field matches a specified regular expression. + * + * ```kotlin + * // Check if the 'email' field matches a valid email pattern + * regexMatch(field("email"), "[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}") + * ``` + * + * @param stringExpression The expression representing the string to match against. + * @param pattern The regular expression to use for the match. + * @return A new [BooleanExpression] representing the regular expression match comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression regexMatch(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string field matches a specified regular expression. + * + * ```kotlin + * // Check if the 'email' field matches a valid email pattern + * regexMatch(field("email"), "[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}") + * ``` + * + * @param stringExpression The expression representing the string to match against. + * @param pattern The regular expression to use for the match. + * @return A new [BooleanExpression] representing the regular expression match comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression regexMatch(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string field matches a specified regular expression. + * + * ```kotlin + * // Check if the 'email' field matches the regex from the 'pattern' field. + * regexMatch("email", field("pattern")) + * ``` + * + * @param fieldName The name of the field containing the string. + * @param pattern The regular expression to use for the match. + * @return A new [BooleanExpression] representing the regular expression match comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression regexMatch(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string field matches a specified regular expression. + * + * ```kotlin + * // Check if the 'email' field matches a valid email pattern + * regexMatch("email", "[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}") + * ``` + * + * @param fieldName The name of the field containing the string. + * @param pattern The regular expression to use for the match. + * @return A new [BooleanExpression] representing the regular expression match comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression regexMatch(java.lang.String fieldName, java.lang.String pattern) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the largest value between multiple input expressions or + * literal values. Based on Firestore's value type ordering. + * + * ```kotlin + * // Returns the larger value between the 'timestamp' field and the current timestamp. + * logicalMaximum(field("timestamp"), currentTimestamp()) + * ``` + * + * @param expr The first operand expression. + * @param others Optional additional expressions or literals. + * @return A new [Expression] representing the logical maximum operation. + */ + +public com.google.firebase.firestore.pipeline.Expression logicalMaximum(com.google.firebase.firestore.pipeline.Expression expr, java.lang.Object... others) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the largest value between multiple input expressions or + * literal values. Based on Firestore's value type ordering. + * + * ```kotlin + * // Returns the larger value between the 'timestamp' field and the current timestamp. + * logicalMaximum("timestamp", currentTimestamp()) + * ``` + * + * @param fieldName The first operand field name. + * @param others Optional additional expressions or literals. + * @return A new [Expression] representing the logical maximum operation. + */ + +public com.google.firebase.firestore.pipeline.Expression logicalMaximum(java.lang.String fieldName, java.lang.Object... others) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the smallest value between multiple input expressions or + * literal values. Based on Firestore's value type ordering. + * + * ```kotlin + * // Returns the smaller value between the 'timestamp' field and the current timestamp. + * logicalMinimum(field("timestamp"), currentTimestamp()) + * ``` + * + * @param expr The first operand expression. + * @param others Optional additional expressions or literals. + * @return A new [Expression] representing the logical minimum operation. + */ + +public com.google.firebase.firestore.pipeline.Expression logicalMinimum(com.google.firebase.firestore.pipeline.Expression expr, java.lang.Object... others) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the smallest value between multiple input expressions or + * literal values. Based on Firestore's value type ordering. + * + * ```kotlin + * // Returns the smaller value between the 'timestamp' field and the current timestamp. + * logicalMinimum("timestamp", currentTimestamp()) + * ``` + * + * @param fieldName The first operand field name. + * @param others Optional additional expressions or literals. + * @return A new [Expression] representing the logical minimum operation. + */ + +public com.google.firebase.firestore.pipeline.Expression logicalMinimum(java.lang.String fieldName, java.lang.Object... others) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that reverses a string. + * + * ```kotlin + * // Reverse the value of the 'myString' field. + * reverse(field("myString")) + * ``` + * + * @param stringExpression An expression evaluating to a string value, which will be reversed. + * @return A new [Expression] representing the reversed string. + */ + +public com.google.firebase.firestore.pipeline.Expression reverse(com.google.firebase.firestore.pipeline.Expression stringExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that reverses a string value from the specified field. + * + * ```kotlin + * // Reverse the value of the 'myString' field. + * reverse("myString") + * ``` + * + * @param fieldName The name of the field that contains the string to reverse. + * @return A new [Expression] representing the reversed string. + */ + +public com.google.firebase.firestore.pipeline.Expression reverse(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string expression contains a specified substring. + * + * ```kotlin + * // Check if the 'description' field contains the value of the 'keyword' field. + * stringContains(field("description"), field("keyword")) + * ``` + * + * @param stringExpression The expression representing the string to perform the comparison on. + * @param substring The expression representing the substring to search for. + * @return A new [BooleanExpression] representing the contains comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression stringContains(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression substring) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string expression contains a specified substring. + * + * ```kotlin + * // Check if the 'description' field contains "example". + * stringContains(field("description"), "example") + * ``` + * + * @param stringExpression The expression representing the string to perform the comparison on. + * @param substring The substring to search for. + * @return A new [BooleanExpression] representing the contains comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression stringContains(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String substring) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string field contains a specified substring. + * + * ```kotlin + * // Check if the 'description' field contains the value of the 'keyword' field. + * stringContains("description", field("keyword")) + * ``` + * + * @param fieldName The name of the field to perform the comparison on. + * @param substring The expression representing the substring to search for. + * @return A new [BooleanExpression] representing the contains comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression stringContains(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression substring) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string field contains a specified substring. + * + * ```kotlin + * // Check if the 'description' field contains "example". + * stringContains("description", "example") + * ``` + * + * @param fieldName The name of the field to perform the comparison on. + * @param substring The substring to search for. + * @return A new [BooleanExpression] representing the contains comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression stringContains(java.lang.String fieldName, java.lang.String substring) { throw new RuntimeException("Stub!"); } + +/** + * ```kotlin + * // Check if the 'fullName' field starts with the value of the 'firstName' field + * startsWith(field("fullName"), field("firstName")) + * ``` + * + * @param stringExpr The expression to check. + * @param prefix The prefix string expression to check for. + * @return A new [BooleanExpression] representing the 'starts with' comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression startsWith(com.google.firebase.firestore.pipeline.Expression stringExpr, com.google.firebase.firestore.pipeline.Expression prefix) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string expression starts with a given [prefix]. + * + * ```kotlin + * // Check if the 'name' field starts with "Mr." + * startsWith(field("name"), "Mr.") + * ``` + * + * @param stringExpr The expression to check. + * @param prefix The prefix string to check for. + * @return A new [BooleanExpression] representing the 'starts with' comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression startsWith(com.google.firebase.firestore.pipeline.Expression stringExpr, java.lang.String prefix) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string expression starts with a given [prefix]. + * + * ```kotlin + * // Check if the 'fullName' field starts with the value of the 'firstName' field + * startsWith("fullName", field("firstName")) + * ``` + * + * @param fieldName The name of field that contains a string to check. + * @param prefix The prefix string expression to check for. + * @return A new [BooleanExpression] representing the 'starts with' comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression startsWith(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression prefix) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string expression starts with a given [prefix]. + * + * ```kotlin + * // Check if the 'name' field starts with "Mr." + * startsWith("name", "Mr.") + * ``` + * + * @param fieldName The name of field that contains a string to check. + * @param prefix The prefix string to check for. + * @return A new [BooleanExpression] representing the 'starts with' comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression startsWith(java.lang.String fieldName, java.lang.String prefix) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string expression ends with a given [suffix]. + * + * ```kotlin + * // Check if the 'url' field ends with the value of the 'extension' field + * endsWith(field("url"), field("extension")) + * ``` + * + * @param stringExpr The expression to check. + * @param suffix The suffix string expression to check for. + * @return A new [BooleanExpression] representing the 'ends with' comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression endsWith(com.google.firebase.firestore.pipeline.Expression stringExpr, com.google.firebase.firestore.pipeline.Expression suffix) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string expression ends with a given [suffix]. + * + * ```kotlin + * // Check if the 'filename' field ends with ".txt" + * endsWith(field("filename"), ".txt") + * ``` + * + * @param stringExpr The expression to check. + * @param suffix The suffix string to check for. + * @return A new [BooleanExpression] representing the 'ends with' comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression endsWith(com.google.firebase.firestore.pipeline.Expression stringExpr, java.lang.String suffix) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string expression ends with a given [suffix]. + * + * ```kotlin + * // Check if the 'url' field ends with the value of the 'extension' field + * endsWith("url", field("extension")) + * ``` + * + * @param fieldName The name of field that contains a string to check. + * @param suffix The suffix string expression to check for. + * @return A new [BooleanExpression] representing the 'ends with' comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression endsWith(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression suffix) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a string expression ends with a given [suffix]. + * + * ```kotlin + * // Check if the 'filename' field ends with ".txt" + * endsWith("filename", ".txt") + * ``` + * + * @param fieldName The name of field that contains a string to check. + * @param suffix The suffix string to check for. + * @return A new [BooleanExpression] representing the 'ends with' comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression endsWith(java.lang.String fieldName, java.lang.String suffix) { throw new RuntimeException("Stub!"); } + +/** + * Reverses the given string expression. + * + * ```kotlin + * // Reverse the value of the 'myString' field. + * stringReverse(field("myString")) + * ``` + * + * @param str The string expression to reverse. + * @return A new [Expression] representing the stringReverse operation. + */ + +public com.google.firebase.firestore.pipeline.Expression stringReverse(com.google.firebase.firestore.pipeline.Expression str) { throw new RuntimeException("Stub!"); } + +/** + * Reverses the given string field. + * + * ```kotlin + * // Reverse the value of the 'myString' field. + * stringReverse("myString") + * ``` + * + * @param fieldName The name of field that contains the string to reverse. + * @return A new [Expression] representing the stringReverse operation. + */ + +public com.google.firebase.firestore.pipeline.Expression stringReverse(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a substring of the given string. + * + * ```kotlin + * // Get a substring of the 'message' field starting at index 5 with length 10. + * substring(field("message"), constant(5), constant(10)) + * ``` + * + * @param stringExpression The expression representing the string to get a substring from. + * @param index The starting index of the substring. + * @param length The length of the substring. + * @return A new [Expression] representing the substring. + */ + +public com.google.firebase.firestore.pipeline.Expression substring(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression index, com.google.firebase.firestore.pipeline.Expression length) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a substring of the given string. + * + * ```kotlin + * // Get a substring of the 'message' field starting at index 5 with length 10. + * substring("message", 5, 10) + * ``` + * + * @param fieldName The name of the field containing the string to get a substring from. + * @param index The starting index of the substring. + * @param length The length of the substring. + * @return A new [Expression] representing the substring. + */ + +public com.google.firebase.firestore.pipeline.Expression substring(java.lang.String fieldName, int index, int length) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that converts a string expression to lowercase. + * + * ```kotlin + * // Convert the 'name' field to lowercase + * toLower(field("name")) + * ``` + * + * @param stringExpression The expression representing the string to convert to lowercase. + * @return A new [Expression] representing the lowercase string. + */ + +public com.google.firebase.firestore.pipeline.Expression toLower(com.google.firebase.firestore.pipeline.Expression stringExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that converts a string field to lowercase. + * + * ```kotlin + * // Convert the 'name' field to lowercase + * toLower("name") + * ``` + * + * @param fieldName The name of the field containing the string to convert to lowercase. + * @return A new [Expression] representing the lowercase string. + */ + +public com.google.firebase.firestore.pipeline.Expression toLower(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that converts a string expression to uppercase. + * + * ```kotlin + * // Convert the 'title' field to uppercase + * toUpper(field("title")) + * ``` + * + * @param stringExpression The expression representing the string to convert to uppercase. + * @return A new [Expression] representing the uppercase string. + */ + +public com.google.firebase.firestore.pipeline.Expression toUpper(com.google.firebase.firestore.pipeline.Expression stringExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that converts a string field to uppercase. + * + * ```kotlin + * // Convert the 'title' field to uppercase + * toUpper("title") + * ``` + * + * @param fieldName The name of the field containing the string to convert to uppercase. + * @return A new [Expression] representing the uppercase string. + */ + +public com.google.firebase.firestore.pipeline.Expression toUpper(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes leading and trailing whitespace from a string expression. + * + * ```kotlin + * // Trim whitespace from the 'userInput' field + * trim(field("userInput")) + * ``` + * + * @param stringExpression The expression representing the string to trim. + * @return A new [Expression] representing the trimmed string. + */ + +public com.google.firebase.firestore.pipeline.Expression trim(com.google.firebase.firestore.pipeline.Expression stringExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes leading and trailing whitespace from a string field. + * + * ```kotlin + * // Trim whitespace from the 'userInput' field + * trim("userInput") + * ``` + * + * @param fieldName The name of the field containing the string to trim. + * @return A new [Expression] representing the trimmed string. + */ + +public com.google.firebase.firestore.pipeline.Expression trim(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes a set of leading and trailing values from an expression. + * + * Note: The values to trim are treated as a **set**, not a substring. + * + * ```kotlin + * // Trim specified characters from the 'userInput' field + * trimValue(field("userInput"), field("valueToTrim")) + * ``` + * + * @param stringExpression The expression representing the string to trim. + * @param valueToTrim The expression evaluated to either a string or a blob. This parameter is + * treated as a set of characters or bytes that will be matched against the input from both + * ends. + * @return A new [Expression] representing the trimmed string or bytes. + */ + +public com.google.firebase.firestore.pipeline.Expression trimValue(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression valueToTrim) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes a set of leading and trailing values from a string field. + * + * Note: The values to trim are treated as a **set**, not a substring. + * + * ```kotlin + * // Trim all '-', and '_' characters from the beginning and the end of 'userInput' field + * trimValue("userInput", "-_") + * ``` + * + * @param fieldName The name of the field containing the string to trim. + * @param valueToTrim This parameter is treated as a set of characters or bytes that will be + * matched against the input from both ends. + * @return A new [Expression] representing the trimmed string. + */ + +public com.google.firebase.firestore.pipeline.Expression trimValue(java.lang.String fieldName, java.lang.String valueToTrim) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes leading whitespace from a string expression. + * + * ```kotlin + * // Trim leading whitespace from the 'text' field. + * ltrim(field("text")) + * ``` + * + * @param stringExpression The expression representing the string to trim. + * @return A new [Expression] representing the ltrim operation. + */ + +public com.google.firebase.firestore.pipeline.Expression ltrim(com.google.firebase.firestore.pipeline.Expression stringExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes leading whitespace from a string field. + * + * ```kotlin + * // Trim leading whitespace from the 'text' field. + * ltrim("text") + * ``` + * + * @param fieldName The name of the field containing the string to trim. + * @return A new [Expression] representing the ltrim operation. + */ + +public com.google.firebase.firestore.pipeline.Expression ltrim(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes a set of leading values from a string expression. + * + * Note: The values to trim are treated as a **set**, not a substring. + * + * ```kotlin + * // Trim all leading '-' and '_' characters from the 'text' field. + * ltrimValue(field("text"), "-_") + * ``` + * + * @param stringExpression The expression representing the string to trim. + * @param valuesToTrim The set of values to remove. + * @return A new [Expression] representing the ltrim operation. + */ + +public com.google.firebase.firestore.pipeline.Expression ltrimValue(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String valuesToTrim) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes a set of leading values from a string expression. + * + * Note: The values to trim are treated as a **set**, not a substring. + * + * ```kotlin + * // Trim leading characters defined by the 'chars' field from the 'text' field. + * ltrimValue(field("text"), field("chars")) + * ``` + * + * @param stringExpression The expression representing the string to trim. + * @param valuesToTrim The expression representing the set of values to remove. + * @return A new [Expression] representing the ltrim operation. + */ + +public com.google.firebase.firestore.pipeline.Expression ltrimValue(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression valuesToTrim) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes specified leading values from a string field. + * + * Note: The values to trim are treated as a **set**, not a substring. + * + * ```kotlin + * // Trim all leading '-' and '_' characters from the 'text' field. + * ltrimValue("text", "-_") + * ``` + * + * @param fieldName The name of the field containing the string to trim. + * @param valuesToTrim The set of values to remove. + * @return A new [Expression] representing the ltrim operation. + */ + +public com.google.firebase.firestore.pipeline.Expression ltrimValue(java.lang.String fieldName, java.lang.String valuesToTrim) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes specified leading values from a string field. + * + * Note: The values to trim are treated as a **set**, not a substring. + * + * ```kotlin + * // Trim leading characters defined by the 'chars' field from the 'text' field. + * ltrimValue("text", field("chars")) + * ``` + * + * @param fieldName The name of the field containing the string to trim. + * @param valuesToTrim The expression representing the set of values to remove. + * @return A new [Expression] representing the ltrim operation. + */ + +public com.google.firebase.firestore.pipeline.Expression ltrimValue(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression valuesToTrim) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes trailing whitespace from a string expression. + * + * ```kotlin + * // Trim trailing whitespace from the 'text' field. + * rtrim(field("text")) + * ``` + * + * @param stringExpression The expression representing the string to trim. + * @return A new [Expression] representing the rtrim operation. + */ + +public com.google.firebase.firestore.pipeline.Expression rtrim(com.google.firebase.firestore.pipeline.Expression stringExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes trailing whitespace from a string field. + * + * ```kotlin + * // Trim trailing whitespace from the 'text' field. + * rtrim("text") + * ``` + * + * @param fieldName The name of the field containing the string to trim. + * @return A new [Expression] representing the rtrim operation. + */ + +public com.google.firebase.firestore.pipeline.Expression rtrim(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes a set of trailing values from a string expression. + * + * Note: The values to trim are treated as a **set**, not a substring. + * + * ```kotlin + * // Trim all trailing '-' and '_' characters from the 'text' field. + * rtrimValue(field("text"), "-_") + * ``` + * + * @param stringExpression The expression representing the string to trim. + * @param valuesToTrim The set of values to remove. + * @return A new [Expression] representing the rtrim operation. + */ + +public com.google.firebase.firestore.pipeline.Expression rtrimValue(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String valuesToTrim) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes a set of trailing values from a string expression. + * + * Note: The values to trim are treated as a **set**, not a substring. + * + * ```kotlin + * // Trim trailing characters defined by the 'chars' field from the 'text' field. + * rtrimValue(field("text"), field("chars")) + * ``` + * + * @param stringExpression The expression representing the string to trim. + * @param valuesToTrim The expression representing the set of values to remove. + * @return A new [Expression] representing the rtrim operation. + */ + +public com.google.firebase.firestore.pipeline.Expression rtrimValue(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression valuesToTrim) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes a set of trailing values from a string field. + * + * Note: The values to trim are treated as a **set**, not a substring. + * + * ```kotlin + * // Trim all trailing '-' and '_' characters from the 'text' field. + * rtrimValue("text", "-_") + * ``` + * + * @param fieldName The name of the field containing the string to trim. + * @param valuesToTrim The set of values to remove. + * @return A new [Expression] representing the rtrim operation. + */ + +public com.google.firebase.firestore.pipeline.Expression rtrimValue(java.lang.String fieldName, java.lang.String valuesToTrim) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes a set of trailing values from a string field. + * + * Note: The values to trim are treated as a **set**, not a substring. + * + * ```kotlin + * // Trim trailing characters defined by the 'chars' field from the 'text' field. + * rtrimValue("text", field("chars")) + * ``` + * + * @param fieldName The name of the field containing the string to trim. + * @param valuesToTrim The expression representing the set of values to remove. + * @return A new [Expression] representing the rtrim operation. + */ + +public com.google.firebase.firestore.pipeline.Expression rtrimValue(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression valuesToTrim) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that repeats a string expression a given number of times. + * + * ```kotlin + * // Repeat the 'name' field 3 times. + * stringRepeat(field("name"), 3) + * ``` + * + * @param stringExpression The expression representing the string to repeat. + * @param count The number of times to repeat the string. + * @return A new [Expression] representing the stringRepeat operation. + */ + +public com.google.firebase.firestore.pipeline.Expression stringRepeat(com.google.firebase.firestore.pipeline.Expression stringExpression, int count) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that repeats a string expression a given number of times. + * + * ```kotlin + * // Repeat the 'name' field the number of times specified in the 'count' field. + * stringRepeat(field("name"), field("count")) + * ``` + * + * @param stringExpression The expression representing the string to repeat. + * @param count The expression representing the number of times to repeat the string. + * @return A new [Expression] representing the stringRepeat operation. + */ + +public com.google.firebase.firestore.pipeline.Expression stringRepeat(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression count) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that repeats a string field a given number of times. + * + * ```kotlin + * // Repeat the 'name' field 3 times. + * stringRepeat("name", 3) + * ``` + * + * @param fieldName The name of the field containing the string to repeat. + * @param count The number of times to repeat the string. + * @return A new [Expression] representing the stringRepeat operation. + */ + +public com.google.firebase.firestore.pipeline.Expression stringRepeat(java.lang.String fieldName, int count) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that repeats a string field a given number of times. + * + * ```kotlin + * // Repeat the 'name' field the number of times specified in the 'count' field. + * stringRepeat("name", field("count")) + * ``` + * + * @param fieldName The name of the field containing the string to repeat. + * @param count The expression representing the number of times to repeat the string. + * @return A new [Expression] representing the stringRepeat operation. + */ + +public com.google.firebase.firestore.pipeline.Expression stringRepeat(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression count) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that replaces all occurrences of a substring with another string. + * + * ```kotlin + * // Replace all occurrences of the 'old' field with the 'new' field in 'text'. + * stringReplaceAll(field("text"), field("old"), field("new")) + * ``` + * + * @param stringExpression The expression representing the original string. + * @param oldValue The expression representing the substring to replace. + * @param newValue The expression representing the replacement string. + * @return A new [Expression] representing the stringReplaceAll operation. + */ + +public com.google.firebase.firestore.pipeline.Expression stringReplaceAll(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression oldValue, com.google.firebase.firestore.pipeline.Expression newValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that replaces all occurrences of a substring with another string. + * + * ```kotlin + * // Replace all occurrences of "cat" with "dog" in the 'text' field. + * stringReplaceAll(field("text"), "cat", "dog") + * ``` + * + * @param stringExpression The expression representing the original string. + * @param oldValue The substring to replace. + * @param newValue The replacement string. + * @return A new [Expression] representing the stringReplaceAll operation. + */ + +public com.google.firebase.firestore.pipeline.Expression stringReplaceAll(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String oldValue, java.lang.String newValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that replaces all occurrences of a substring with another string in a + * field. + * + * ```kotlin + * // Replace all occurrences of the 'old' field with the 'new' field in 'text'. + * stringReplaceAll("text", field("old"), field("new")) + * ``` + * + * @param fieldName The name of the field containing the original string. + * @param oldValue The expression representing the substring to replace. + * @param newValue The expression representing the replacement string. + * @return A new [Expression] representing the stringReplaceAll operation. + */ + +public com.google.firebase.firestore.pipeline.Expression stringReplaceAll(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression oldValue, com.google.firebase.firestore.pipeline.Expression newValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that replaces all occurrences of a substring with another string in a + * field. + * + * ```kotlin + * // Replace all occurrences of "cat" with "dog" in the 'text' field. + * stringReplaceAll("text", "cat", "dog") + * ``` + * + * @param fieldName The name of the field containing the original string. + * @param oldValue The substring to replace. + * @param newValue The replacement string. + * @return A new [Expression] representing the stringReplaceAll operation. + */ + +public com.google.firebase.firestore.pipeline.Expression stringReplaceAll(java.lang.String fieldName, java.lang.String oldValue, java.lang.String newValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that replaces the first occurrence of a substring with another string. + * + * ```kotlin + * // Replace the first occurrence of the 'old' field with the 'new' field in 'text'. + * stringReplaceOne(field("text"), field("old"), field("new")) + * ``` + * + * @param stringExpression The expression representing the original string. + * @param oldValue The expression representing the substring to replace. + * @param newValue The expression representing the replacement string. + * @return A new [Expression] representing the stringReplaceOne operation. + */ + +public com.google.firebase.firestore.pipeline.Expression stringReplaceOne(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression oldValue, com.google.firebase.firestore.pipeline.Expression newValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that replaces the first occurrence of a substring with another string. + * + * ```kotlin + * // Replace the first occurrence of "cat" with "dog" in the 'text' field. + * stringReplaceOne(field("text"), "cat", "dog") + * ``` + * + * @param stringExpression The expression representing the original string. + * @param oldValue The substring to replace. + * @param newValue The replacement string. + * @return A new [Expression] representing the stringReplaceOne operation. + */ + +public com.google.firebase.firestore.pipeline.Expression stringReplaceOne(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String oldValue, java.lang.String newValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that replaces the first occurrence of a substring with another string + * in a field. + * + * ```kotlin + * // Replace the first occurrence of the 'old' field with the 'new' field in 'text'. + * stringReplaceOne("text", field("old"), field("new")) + * ``` + * + * @param fieldName The name of the field containing the original string. + * @param oldValue The expression representing the substring to replace. + * @param newValue The expression representing the replacement string. + * @return A new [Expression] representing the stringReplaceOne operation. + */ + +public com.google.firebase.firestore.pipeline.Expression stringReplaceOne(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression oldValue, com.google.firebase.firestore.pipeline.Expression newValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that replaces the first occurrence of a substring with another string + * in a field. + * + * ```kotlin + * // Replace the first occurrence of "cat" with "dog" in the 'text' field. + * stringReplaceOne("text", "cat", "dog") + * ``` + * + * @param fieldName The name of the field containing the original string. + * @param oldValue The substring to replace. + * @param newValue The replacement string. + * @return A new [Expression] representing the stringReplaceOne operation. + */ + +public com.google.firebase.firestore.pipeline.Expression stringReplaceOne(java.lang.String fieldName, java.lang.String oldValue, java.lang.String newValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the 0-based index of the first occurrence of the specified + * substring. + * + * ```kotlin + * // Get the index of the 'search' field within the 'text' field. + * stringIndexOf(field("text"), field("search")) + * ``` + * + * @param stringExpression The expression representing the string to search within. + * @param substring The expression representing the substring to search for. + * @return A new [Expression] representing the stringIndexOf operation. + */ + +public com.google.firebase.firestore.pipeline.Expression stringIndexOf(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression substring) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the 0-based index of the first occurrence of the specified + * substring. + * + * ```kotlin + * // Get the index of "world" within the 'text' field. + * stringIndexOf(field("text"), "world") + * ``` + * + * @param stringExpression The expression representing the string to search within. + * @param substring The substring to search for. + * @return A new [Expression] representing the stringIndexOf operation. + */ + +public com.google.firebase.firestore.pipeline.Expression stringIndexOf(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String substring) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the 0-based index of the first occurrence of the specified + * substring in a field. + * + * ```kotlin + * // Get the index of the 'search' field within the 'text' field. + * stringIndexOf("text", field("search")) + * ``` + * + * @param fieldName The name of the field containing the string to search within. + * @param substring The expression representing the substring to search for. + * @return A new [Expression] representing the stringIndexOf operation. + */ + +public com.google.firebase.firestore.pipeline.Expression stringIndexOf(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression substring) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the 0-based index of the first occurrence of the specified + * substring in a field. + * + * ```kotlin + * // Get the index of "world" within the 'text' field. + * stringIndexOf("text", "world") + * ``` + * + * @param fieldName The name of the field containing the string to search within. + * @param substring The substring to search for. + * @return A new [Expression] representing the stringIndexOf operation. + */ + +public com.google.firebase.firestore.pipeline.Expression stringIndexOf(java.lang.String fieldName, java.lang.String substring) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that concatenates string expressions together. + * + * ```kotlin + * // Combine the 'firstName', " ", and 'lastName' fields into a single string + * stringConcat(field("firstName"), constant(" "), field("lastName")) + * ``` + * + * @param firstString The expression representing the initial string value. + * @param otherStrings Optional additional string expressions to concatenate. + * @return A new [Expression] representing the concatenated string. + */ + +public com.google.firebase.firestore.pipeline.Expression stringConcat(com.google.firebase.firestore.pipeline.Expression firstString, com.google.firebase.firestore.pipeline.Expression... otherStrings) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that concatenates string expressions together. + * + * ```kotlin + * // Combine the 'firstName', " ", and 'lastName' fields into a single string + * stringConcat(field("firstName"), " ", field("lastName")) + * ``` + * + * @param firstString The expression representing the initial string value. + * @param otherStrings Optional additional string expressions or string constants to + * concatenate. + * @return A new [Expression] representing the concatenated string. + */ + +public com.google.firebase.firestore.pipeline.Expression stringConcat(com.google.firebase.firestore.pipeline.Expression firstString, java.lang.Object... otherStrings) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that concatenates string expressions together. + * + * ```kotlin + * // Combine the 'firstName', " ", and 'lastName' fields into a single string + * stringConcat("firstName", constant(" "), field("lastName")) + * ``` + * + * @param fieldName The field name containing the initial string value. + * @param otherStrings Optional additional string expressions to concatenate. + * @return A new [Expression] representing the concatenated string. + */ + +public com.google.firebase.firestore.pipeline.Expression stringConcat(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression... otherStrings) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that concatenates string expressions together. + * + * ```kotlin + * // Combine the 'firstName', " ", and 'lastName' fields into a single string + * stringConcat("firstName", " ", "lastName") + * ``` + * + * @param fieldName The field name containing the initial string value. + * @param otherStrings Optional additional string expressions or string constants to + * concatenate. + * @return A new [Expression] representing the concatenated string. + */ + +public com.google.firebase.firestore.pipeline.Expression stringConcat(java.lang.String fieldName, java.lang.Object... otherStrings) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that creates a Firestore map value from an input object. + * + * ```kotlin + * // Create a map with a constant key and a field value + * map(mapOf("name" to field("productName"), "quantity" to 1)) + * ``` + * + * @param elements The input map to evaluate in the expression. + * @return A new [Expression] representing the map function. + */ + +public com.google.firebase.firestore.pipeline.Expression map(java.util.Map elements) { throw new RuntimeException("Stub!"); } + +/** + * Accesses a field/property of a document or Map using the provided [key]. + * + * @param expression The expression evaluating to a map or document. + * @param key The key of the field to access. + * @return An [Expression] representing the value of the field. + */ + +public com.google.firebase.firestore.pipeline.Expression getField(com.google.firebase.firestore.pipeline.Expression expression, java.lang.String key) { throw new RuntimeException("Stub!"); } + +/** + * Accesses a field/property of a document or Map using the provided [key]. + * + * @param fieldName The field name of the map or document field. + * @param key The key of the field to access. + * @return An [Expression] representing the value of the field. + */ + +public com.google.firebase.firestore.pipeline.Expression getField(java.lang.String fieldName, java.lang.String key) { throw new RuntimeException("Stub!"); } + +/** + * Accesses a field/property of a document or Map using the provided [keyExpression]. + * + * @param expression The expression evaluating to a Map or Document. + * @param keyExpression The expression evaluating to the key. + * @return A new [Expression] representing the value of the field. + */ + +public com.google.firebase.firestore.pipeline.Expression getField(com.google.firebase.firestore.pipeline.Expression expression, com.google.firebase.firestore.pipeline.Expression keyExpression) { throw new RuntimeException("Stub!"); } + +/** + * Accesses a field/property of a document or Map using the provided [keyExpression]. + * + * @param fieldName The field name of the map or document field. + * @param keyExpression The expression evaluating to the key. + * @return A new [Expression] representing the value of the field. + */ + +public com.google.firebase.firestore.pipeline.Expression getField(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression keyExpression) { throw new RuntimeException("Stub!"); } + +/** + * Accesses a value from a map (object) field using the provided [key]. + * + * ```kotlin + * // Get the 'city' value from the 'address' map field + * mapGet(field("address"), "city") + * ``` + * + * @param mapExpression The expression representing the map. + * @param key The key to access in the map. + * @return A new [Expression] representing the value associated with the given key in the map. + */ + +public com.google.firebase.firestore.pipeline.Expression mapGet(com.google.firebase.firestore.pipeline.Expression mapExpression, java.lang.String key) { throw new RuntimeException("Stub!"); } + +/** + * Accesses a value from a map (object) field using the provided [key]. + * + * ```kotlin + * // Get the 'city' value from the 'address' map field + * mapGet("address", "city") + * ``` + * + * @param fieldName The field name of the map field. + * @param key The key to access in the map. + * @return A new [Expression] representing the value associated with the given key in the map. + */ + +public com.google.firebase.firestore.pipeline.Expression mapGet(java.lang.String fieldName, java.lang.String key) { throw new RuntimeException("Stub!"); } + +/** + * Accesses a value from a map (object) field using the provided [keyExpression]. + * + * ```kotlin + * // Get the value from the 'address' map field, using the key from the 'keyField' field + * mapGet(field("address"), field("keyField")) + * ``` + * + * @param mapExpression The expression representing the map. + * @param keyExpression The key to access in the map. + * @return A new [Expression] representing the value associated with the given key in the map. + */ + +public com.google.firebase.firestore.pipeline.Expression mapGet(com.google.firebase.firestore.pipeline.Expression mapExpression, com.google.firebase.firestore.pipeline.Expression keyExpression) { throw new RuntimeException("Stub!"); } + +/** + * Accesses a value from a map (object) field using the provided [keyExpression]. + * + * ```kotlin + * // Get the value from the 'address' map field, using the key from the 'keyField' field + * mapGet("address", field("keyField")) + * ``` + * + * @param fieldName The field name of the map field. + * @param keyExpression The key to access in the map. + * @return A new [Expression] representing the value associated with the given key in the map. + */ + +public com.google.firebase.firestore.pipeline.Expression mapGet(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression keyExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that merges multiple maps into a single map. If multiple maps have the + * same key, the later value is used. + * + * ```kotlin + * // Merges the map in the settings field with, a map literal, and a map in + * // that is conditionally returned by another expression + * mapMerge( + * field("settings"), + * map(mapOf("enabled" to true)), + * conditional( + * field("isAdmin").equal(true), + * map(mapOf("admin" to true)), + * map(emptyMap()) + * ) + * ) + * ``` + * + * @param firstMap First map expression that will be merged. + * @param secondMap Second map expression that will be merged. + * @param otherMaps Additional maps to merge. + * @return A new [Expression] representing the mapMerge operation. + */ + +public com.google.firebase.firestore.pipeline.Expression mapMerge(com.google.firebase.firestore.pipeline.Expression firstMap, com.google.firebase.firestore.pipeline.Expression secondMap, com.google.firebase.firestore.pipeline.Expression... otherMaps) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that merges multiple maps into a single map. If multiple maps have the + * same key, the later value is used. + * + * ```kotlin + * // Merges the map in the settings field with, a map literal, and a map in + * // that is conditionally returned by another expression + * mapMerge( + * "settings", + * map(mapOf("enabled" to true)), + * conditional( + * field("isAdmin").equal(true), + * map(mapOf("admin" to true)), + * map(emptyMap()) + * ) + * ) + * ``` + * + * @param firstMapFieldName First map field name that will be merged. + * @param secondMap Second map expression that will be merged. + * @param otherMaps Additional maps to merge. + * @return A new [Expression] representing the mapMerge operation. + */ + +public com.google.firebase.firestore.pipeline.Expression mapMerge(java.lang.String firstMapFieldName, com.google.firebase.firestore.pipeline.Expression secondMap, com.google.firebase.firestore.pipeline.Expression... otherMaps) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes a key from the map produced by evaluating an expression. + * + * ```kotlin + * // Removes the key 'baz' from the input map. + * mapRemove(map(mapOf("foo" to "bar", "baz" to true)), constant("baz")) + * ``` + * + * @param mapExpr An expression that evaluates to a map. + * @param key The name of the key to remove from the input map. + * @return A new [Expression] that evaluates to a modified map. + */ + +public com.google.firebase.firestore.pipeline.Expression mapRemove(com.google.firebase.firestore.pipeline.Expression mapExpr, com.google.firebase.firestore.pipeline.Expression key) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes a key from the map produced by evaluating an expression. + * + * ```kotlin + * // Removes the key 'city' field from the map in the address field of the input document. + * mapRemove("address", constant("city")) + * ``` + * + * @param mapField The name of a field containing a map value. + * @param key The name of the key to remove from the input map. + * @return A new [Expression] that evaluates to a modified map. + */ + +public com.google.firebase.firestore.pipeline.Expression mapRemove(java.lang.String mapField, com.google.firebase.firestore.pipeline.Expression key) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes a key from the map produced by evaluating an expression. + * + * ```kotlin + * // Removes the key 'baz' from the input map. + * mapRemove(map(mapOf("foo" to "bar", "baz" to true)), "baz") + * ``` + * + * @param mapExpr An expression that evaluates to a map. + * @param key The name of the key to remove from the input map. + * @return A new [Expression] that evaluates to a modified map. + */ + +public com.google.firebase.firestore.pipeline.Expression mapRemove(com.google.firebase.firestore.pipeline.Expression mapExpr, java.lang.String key) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that removes a key from the map produced by evaluating an expression. + * + * ```kotlin + * // Removes the key 'city' field from the map in the address field of the input document. + * mapRemove("address", "city") + * ``` + * + * @param mapField The name of a field containing a map value. + * @param key The name of the key to remove from the input map. + * @return A new [Expression] that evaluates to a modified map. + */ + +public com.google.firebase.firestore.pipeline.Expression mapRemove(java.lang.String mapField, java.lang.String key) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a new map with the specified entries added or updated. + * + * Note: This only performs shallow updates to the map. Setting a value to `null` will retain + * the key with a `null` value. To remove a key entirely, use `mapRemove`. + * + * ```kotlin + * // Set the 'city' to "San Francisco" in the 'address' map + * mapSet(field("address"), constant("city"), constant("San Francisco")); + * ``` + * + * @param mapExpr The expression representing the map. + * @param key The key to set. Must be an expression representing a string. + * @param value The value to set. + * @param moreKeyValues Additional key-value pairs to set. + * @return A new [Expression] representing the map with the entries set. + */ + +public com.google.firebase.firestore.pipeline.Expression mapSet(com.google.firebase.firestore.pipeline.Expression mapExpr, com.google.firebase.firestore.pipeline.Expression key, com.google.firebase.firestore.pipeline.Expression value, com.google.firebase.firestore.pipeline.Expression... moreKeyValues) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a new map with the specified entries added or updated. + * + * Note: This only performs shallow updates to the map. Setting a value to `null` will retain + * the key with a `null` value. To remove a key entirely, use `mapRemove`. + * + * ```kotlin + * // Set the 'city' to "San Francisco" in the 'address' map + * mapSet(field("address"), "city", "San Francisco"); + * ``` + * + * @param mapExpr The map field to set entries in. + * @param key The key to set. + * @param value The value to set. + * @param moreKeyValues Additional key-value pairs to set. + * @return A new [Expression] representing the map with the entries set. + */ + +public com.google.firebase.firestore.pipeline.Expression mapSet(com.google.firebase.firestore.pipeline.Expression mapExpr, java.lang.String key, java.lang.Object value, java.lang.Object... moreKeyValues) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a new map with the specified entries added or updated. + * + * Note: This only performs shallow updates to the map. Setting a value to `null` will retain + * the key with a `null` value. To remove a key entirely, use `mapRemove`. + * + * ```kotlin + * // Set the 'city' to "San Francisco" in the 'address' map + * mapSet("address", constant("city"), constant("San Francisco")) + * ``` + * + * @param mapField The map field to set entries in. + * @param key The key to set. Must be an expression representing a string. + * @param value The value to set. + * @param moreKeyValues Additional key-value pairs to set. + * @return A new [Expression] representing the map with the entries set. + */ + +public com.google.firebase.firestore.pipeline.Expression mapSet(java.lang.String mapField, com.google.firebase.firestore.pipeline.Expression key, com.google.firebase.firestore.pipeline.Expression value, com.google.firebase.firestore.pipeline.Expression... moreKeyValues) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a new map with the specified entries added or updated. + * + * Note: This only performs shallow updates to the map. Setting a value to `null` will retain + * the key with a `null` value. To remove a key entirely, use `mapRemove`. + * + * ```kotlin + * // Set the 'city' to "San Francisco" in the 'address' map + * mapSet("address", "city", "San Francisco") + * ``` + * + * @param mapField The map field to set entries in. + * @param key The key to set. Must be an expression representing a string. + * @param value The value to set. + * @param moreKeyValues Additional key-value pairs to set. + * @return A new [Expression] representing the map with the entries set. + */ + +public com.google.firebase.firestore.pipeline.Expression mapSet(java.lang.String mapField, java.lang.String key, java.lang.Object value, java.lang.Object... moreKeyValues) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the keys of a map. + * + * Note: While the backend generally preserves insertion order, relying on the order of the + * output array is not guaranteed and should be avoided. + * + * ```kotlin + * // Get the keys of a map expression. + * mapKeys(map(mapOf("a" to 1, "b" to 2))) + * ``` + * + * @param mapExpr The expression representing the map to get the keys of. + * @return A new [Expression] representing the keys of the map. + */ + +public com.google.firebase.firestore.pipeline.Expression mapKeys(com.google.firebase.firestore.pipeline.Expression mapExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the keys of a map. + * + * Note: While the backend generally preserves insertion order, relying on the order of the + * output array is not guaranteed and should be avoided. + * + * ```kotlin + * // Get the keys of the 'metadata' map field. + * mapKeys("metadata") + * ``` + * + * @param mapField The map field to get the keys of. + * @return A new [Expression] representing the keys of the map. + */ + +public com.google.firebase.firestore.pipeline.Expression mapKeys(java.lang.String mapField) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the values of a map. + * + * Note: While the backend generally preserves insertion order, relying on the order of the + * output array is not guaranteed and should be avoided. + * + * ```kotlin + * // Get the values of a map expression. + * mapValues(map(mapOf("a" to 1, "b" to 2))) + * ``` + * + * @param mapExpr The expression representing the map to get the values of. + * @return A new [Expression] representing the values of the map. + */ + +public com.google.firebase.firestore.pipeline.Expression mapValues(com.google.firebase.firestore.pipeline.Expression mapExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the values of a map. + * + * Note: While the backend generally preserves insertion order, relying on the order of the + * output array is not guaranteed and should be avoided. + * + * ```kotlin + * // Get the values of the 'metadata' map field. + * mapValues("metadata") + * ``` + * + * @param mapField The map field to get the values of. + * @return A new [Expression] representing the values of the map. + */ + +public com.google.firebase.firestore.pipeline.Expression mapValues(java.lang.String mapField) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the entries of a map as an array of maps, where each map + * contains a "k" property for the key and a "v" property for the value. + * + * Note: While the backend generally preserves insertion order, relying on the order of the + * output array is not guaranteed and should be avoided. + * + * ```kotlin + * // Get the entries of a map expression. + * mapEntries(map(mapOf("a" to 1, "b" to 2))) + * ``` + * + * @param mapExpr The expression representing the map to get the entries of. + * @return A new [Expression] representing the entries of the map. + */ + +public com.google.firebase.firestore.pipeline.Expression mapEntries(com.google.firebase.firestore.pipeline.Expression mapExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the entries of a map as an array of maps. + * + * Note: While the backend generally preserves insertion order, relying on the order of the + * output array is not guaranteed and should be avoided. + * + * ```kotlin + * // Get the entries of the 'metadata' map field. + * mapEntries("metadata") + * ``` + * + * @param mapField The map field to get the entries of. + * @return A new [Expression] representing the entries of the map. + */ + +public com.google.firebase.firestore.pipeline.Expression mapEntries(java.lang.String mapField) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the Cosine distance between two vector expressions. + * + * ```kotlin + * // Calculate the cosine distance between the 'userVector' field and the 'itemVector' field + * cosineDistance(field("userVector"), field("itemVector")) + * ``` + * + * @param vector1 The first vector (represented as an Expression) to compare against. + * @param vector2 The other vector (represented as an Expression) to compare against. + * @return A new [Expression] representing the cosine distance between the two vectors. + */ + +public com.google.firebase.firestore.pipeline.Expression cosineDistance(com.google.firebase.firestore.pipeline.Expression vector1, com.google.firebase.firestore.pipeline.Expression vector2) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the Cosine distance between vector expression and a vector literal. + * + * ```kotlin + * // Calculate the Cosine distance between the 'location' field and a target location + * cosineDistance(field("location"), doubleArrayOf(37.7749, -122.4194)) + * ``` + * + * @param vector1 The first vector (represented as an Expression) to compare against. + * @param vector2 The other vector (as an array of doubles) to compare against. + * @return A new [Expression] representing the cosine distance between the two vectors. + */ + +public com.google.firebase.firestore.pipeline.Expression cosineDistance(com.google.firebase.firestore.pipeline.Expression vector1, double[] vector2) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the Cosine distance between vector expression and a vector literal. + * + * ```kotlin + * // Calculate the Cosine distance between the 'location' field and a target location + * cosineDistance(field("location"), VectorValue.from(listOf(37.7749, -122.4194))) + * ``` + * + * @param vector1 The first vector (represented as an [Expression]) to compare against. + * @param vector2 The other vector (represented as an [VectorValue]) to compare against. + * @return A new [Expression] representing the cosine distance between the two vectors. + */ + +public com.google.firebase.firestore.pipeline.Expression cosineDistance(com.google.firebase.firestore.pipeline.Expression vector1, com.google.firebase.firestore.VectorValue vector2) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the Cosine distance between a vector field and a vector expression. + * + * ```kotlin + * // Calculate the cosine distance between the 'userVector' field and the 'itemVector' field + * cosineDistance("userVector", field("itemVector")) + * ``` + * + * @param vectorFieldName The name of the field containing the first vector. + * @param vector The other vector (represented as an Expression) to compare against. + * @return A new [Expression] representing the cosine distance between the two vectors. + */ + +public com.google.firebase.firestore.pipeline.Expression cosineDistance(java.lang.String vectorFieldName, com.google.firebase.firestore.pipeline.Expression vector) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the Cosine distance between a vector field and a vector literal. + * + * ```kotlin + * // Calculate the Cosine distance between the 'location' field and a target location + * cosineDistance("location", doubleArrayOf(37.7749, -122.4194)) + * ``` + * + * @param vectorFieldName The name of the field containing the first vector. + * @param vector The other vector (as an array of doubles) to compare against. + * @return A new [Expression] representing the cosine distance between the two vectors. + */ + +public com.google.firebase.firestore.pipeline.Expression cosineDistance(java.lang.String vectorFieldName, double[] vector) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the Cosine distance between a vector field and a vector literal. + * + * ```kotlin + * // Calculate the Cosine distance between the 'location' field and a target location + * cosineDistance("location", VectorValue.from(listOf(37.7749, -122.4194))) + * ``` + * + * @param vectorFieldName The name of the field containing the first vector. + * @param vector The other vector (represented as an [VectorValue]) to compare against. + * @return A new [Expression] representing the cosine distance between the two vectors. + */ + +public com.google.firebase.firestore.pipeline.Expression cosineDistance(java.lang.String vectorFieldName, com.google.firebase.firestore.VectorValue vector) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the dot product distance between two vector expressions. + * + * ```kotlin + * // Calculate the dot product between the 'userVector' field and the 'itemVector' field + * dotProduct(field("userVector"), field("itemVector")) + * ``` + * + * @param vector1 The first vector (represented as an Expression) to compare against. + * @param vector2 The other vector (represented as an Expression) to compare against. + * @return A new [Expression] representing the dot product distance between the two vectors. + */ + +public com.google.firebase.firestore.pipeline.Expression dotProduct(com.google.firebase.firestore.pipeline.Expression vector1, com.google.firebase.firestore.pipeline.Expression vector2) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the dot product distance between vector expression and a vector literal. + * + * ```kotlin + * // Calculate the dot product between the 'vector' field and a constant vector + * dotProduct(field("vector"), doubleArrayOf(1.0, 2.0, 3.0)) + * ``` + * + * @param vector1 The first vector (represented as an Expression) to compare against. + * @param vector2 The other vector (as an array of doubles) to compare against. + * @return A new [Expression] representing the dot product distance between the two vectors. + */ + +public com.google.firebase.firestore.pipeline.Expression dotProduct(com.google.firebase.firestore.pipeline.Expression vector1, double[] vector2) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the dot product distance between vector expression and a vector literal. + * + * ```kotlin + * // Calculate the dot product between the 'vector' field and a constant vector + * dotProduct(field("vector"), VectorValue.from(listOf(1.0, 2.0, 3.0))) + * ``` + * + * @param vector1 The first vector (represented as an [Expression]) to compare against. + * @param vector2 The other vector (represented as an [VectorValue]) to compare against. + * @return A new [Expression] representing the dot product distance between the two vectors. + */ + +public com.google.firebase.firestore.pipeline.Expression dotProduct(com.google.firebase.firestore.pipeline.Expression vector1, com.google.firebase.firestore.VectorValue vector2) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the dot product distance between a vector field and a vector expression. + * + * ```kotlin + * // Calculate the dot product between the 'userVector' field and the 'itemVector' field + * dotProduct("userVector", field("itemVector")) + * ``` + * + * @param vectorFieldName The name of the field containing the first vector. + * @param vector The other vector (represented as an Expression) to compare against. + * @return A new [Expression] representing the dot product distance between the two vectors. + */ + +public com.google.firebase.firestore.pipeline.Expression dotProduct(java.lang.String vectorFieldName, com.google.firebase.firestore.pipeline.Expression vector) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the dot product distance between vector field and a vector literal. + * + * ```kotlin + * // Calculate the dot product between the 'vector' field and a constant vector + * dotProduct("vector", doubleArrayOf(1.0, 2.0, 3.0)) + * ``` + * + * @param vectorFieldName The name of the field containing the first vector. + * @param vector The other vector (as an array of doubles) to compare against. + * @return A new [Expression] representing the dot product distance between the two vectors. + */ + +public com.google.firebase.firestore.pipeline.Expression dotProduct(java.lang.String vectorFieldName, double[] vector) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the dot product distance between a vector field and a vector literal. + * + * ```kotlin + * // Calculate the dot product between the 'vector' field and a constant vector + * dotProduct("vector", VectorValue.from(listOf(1.0, 2.0, 3.0))) + * ``` + * + * @param vectorFieldName The name of the field containing the first vector. + * @param vector The other vector (represented as an [VectorValue]) to compare against. + * @return A new [Expression] representing the dot product distance between the two vectors. + */ + +public com.google.firebase.firestore.pipeline.Expression dotProduct(java.lang.String vectorFieldName, com.google.firebase.firestore.VectorValue vector) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the Euclidean distance between two vector expressions. + * + * ```kotlin + * // Calculate the Euclidean distance between the 'userVector' field and the 'itemVector' field + * euclideanDistance(field("userVector"), field("itemVector")) + * ``` + * + * @param vector1 The first vector (represented as an Expression) to compare against. + * @param vector2 The other vector (represented as an Expression) to compare against. + * @return A new [Expression] representing the Euclidean distance between the two vectors. + */ + +public com.google.firebase.firestore.pipeline.Expression euclideanDistance(com.google.firebase.firestore.pipeline.Expression vector1, com.google.firebase.firestore.pipeline.Expression vector2) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the Euclidean distance between vector expression and a vector literal. + * + * ```kotlin + * // Calculate the Euclidean distance between the 'vector' field and a constant vector + * euclideanDistance(field("vector"), doubleArrayOf(1.0, 2.0, 3.0)) + * ``` + * + * @param vector1 The first vector (represented as an Expression) to compare against. + * @param vector2 The other vector (as an array of doubles) to compare against. + * @return A new [Expression] representing the Euclidean distance between the two vectors. + */ + +public com.google.firebase.firestore.pipeline.Expression euclideanDistance(com.google.firebase.firestore.pipeline.Expression vector1, double[] vector2) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the Euclidean distance between vector expression and a vector literal. + * + * ```kotlin + * // Calculate the Euclidean distance between the 'vector' field and a constant vector + * euclideanDistance(field("vector"), VectorValue.from(listOf(1.0, 2.0, 3.0))) + * ``` + * + * @param vector1 The first vector (represented as an [Expression]) to compare against. + * @param vector2 The other vector (represented as an [VectorValue]) to compare against. + * @return A new [Expression] representing the Euclidean distance between the two vectors. + */ + +public com.google.firebase.firestore.pipeline.Expression euclideanDistance(com.google.firebase.firestore.pipeline.Expression vector1, com.google.firebase.firestore.VectorValue vector2) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the Euclidean distance between a vector field and a vector expression. + * + * ```kotlin + * // Calculate the Euclidean distance between the 'userVector' field and the 'itemVector' field + * euclideanDistance("userVector", field("itemVector")) + * ``` + * + * @param vectorFieldName The name of the field containing the first vector. + * @param vector The other vector (represented as an Expression) to compare against. + * @return A new [Expression] representing the Euclidean distance between the two vectors. + */ + +public com.google.firebase.firestore.pipeline.Expression euclideanDistance(java.lang.String vectorFieldName, com.google.firebase.firestore.pipeline.Expression vector) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the Euclidean distance between a vector field and a vector literal. + * + * ```kotlin + * // Calculate the Euclidean distance between the 'vector' field and a constant vector + * euclideanDistance("vector", doubleArrayOf(1.0, 2.0, 3.0)) + * ``` + * + * @param vectorFieldName The name of the field containing the first vector. + * @param vector The other vector (as an array of doubles) to compare against. + * @return A new [Expression] representing the Euclidean distance between the two vectors. + */ + +public com.google.firebase.firestore.pipeline.Expression euclideanDistance(java.lang.String vectorFieldName, double[] vector) { throw new RuntimeException("Stub!"); } + +/** + * Calculates the Euclidean distance between a vector field and a vector literal. + * + * ```kotlin + * // Calculate the Euclidean distance between the 'vector' field and a constant vector + * euclideanDistance("vector", VectorValue.from(listOf(1.0, 2.0, 3.0))) + * ``` + * + * @param vectorFieldName The name of the field containing the first vector. + * @param vector The other vector (represented as an [VectorValue]) to compare against. + * @return A new [Expression] representing the Euclidean distance between the two vectors. + */ + +public com.google.firebase.firestore.pipeline.Expression euclideanDistance(java.lang.String vectorFieldName, com.google.firebase.firestore.VectorValue vector) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the length (dimension) of a Firestore Vector. + * + * ```kotlin + * // Get the vector length (dimension) of the field 'embedding'. + * vectorLength(field("embedding")) + * ``` + * + * @param vectorExpression The expression representing the Firestore Vector. + * @return A new [Expression] representing the length (dimension) of the vector. + */ + +public com.google.firebase.firestore.pipeline.Expression vectorLength(com.google.firebase.firestore.pipeline.Expression vectorExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the length (dimension) of a Firestore Vector. + * + * ```kotlin + * // Get the vector length (dimension) of the field 'embedding'. + * vectorLength("embedding") + * ``` + * + * @param fieldName The name of the field containing the Firestore Vector. + * @return A new [Expression] representing the length (dimension) of the vector. + */ + +public com.google.firebase.firestore.pipeline.Expression vectorLength(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that evaluates to the current server timestamp. + * + * ```kotlin + * // Get the current server timestamp + * currentTimestamp() + * ``` + * + * @return A new [Expression] representing the current server timestamp. + */ + +public com.google.firebase.firestore.pipeline.Expression currentTimestamp() { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that interprets an expression as the number of microseconds since the + * Unix epoch (1970-01-01 00:00:00 UTC) and returns a timestamp. + * + * ```kotlin + * // Interpret the 'microseconds' field as microseconds since epoch. + * unixMicrosToTimestamp(field("microseconds")) + * ``` + * + * @param expr The expression representing the number of microseconds since epoch. + * @return A new [Expression] representing the timestamp. + */ + +public com.google.firebase.firestore.pipeline.Expression unixMicrosToTimestamp(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that interprets a field's value as the number of microseconds since the + * Unix epoch (1970-01-01 00:00:00 UTC) and returns a timestamp. + * + * ```kotlin + * // Interpret the 'microseconds' field as microseconds since epoch. + * unixMicrosToTimestamp("microseconds") + * ``` + * + * @param fieldName The name of the field containing the number of microseconds since epoch. + * @return A new [Expression] representing the timestamp. + */ + +public com.google.firebase.firestore.pipeline.Expression unixMicrosToTimestamp(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that converts a timestamp expression to the number of microseconds + * since the Unix epoch (1970-01-01 00:00:00 UTC). + * + * ```kotlin + * // Convert the 'timestamp' field to microseconds since epoch. + * timestampToUnixMicros(field("timestamp")) + * ``` + * + * @param expr The expression representing the timestamp. + * @return A new [Expression] representing the number of microseconds since epoch. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampToUnixMicros(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that converts a timestamp field to the number of microseconds since the + * Unix epoch (1970-01-01 00:00:00 UTC). + * + * ```kotlin + * // Convert the 'timestamp' field to microseconds since epoch. + * timestampToUnixMicros("timestamp") + * ``` + * + * @param fieldName The name of the field that contains the timestamp. + * @return A new [Expression] representing the number of microseconds since epoch. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampToUnixMicros(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that interprets an expression as the number of milliseconds since the + * Unix epoch (1970-01-01 00:00:00 UTC) and returns a timestamp. + * + * ```kotlin + * // Interpret the 'milliseconds' field as milliseconds since epoch. + * unixMillisToTimestamp(field("milliseconds")) + * ``` + * + * @param expr The expression representing the number of milliseconds since epoch. + * @return A new [Expression] representing the timestamp. + */ + +public com.google.firebase.firestore.pipeline.Expression unixMillisToTimestamp(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that interprets a field's value as the number of milliseconds since the + * Unix epoch (1970-01-01 00:00:00 UTC) and returns a timestamp. + * + * ```kotlin + * // Interpret the 'milliseconds' field as milliseconds since epoch. + * unixMillisToTimestamp("milliseconds") + * ``` + * + * @param fieldName The name of the field containing the number of milliseconds since epoch. + * @return A new [Expression] representing the timestamp. + */ + +public com.google.firebase.firestore.pipeline.Expression unixMillisToTimestamp(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that converts a timestamp expression to the number of milliseconds + * since the Unix epoch (1970-01-01 00:00:00 UTC). + * + * ```kotlin + * // Convert the 'timestamp' field to milliseconds since epoch. + * timestampToUnixMillis(field("timestamp")) + * ``` + * + * @param expr The expression representing the timestamp. + * @return A new [Expression] representing the number of milliseconds since epoch. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampToUnixMillis(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that converts a timestamp field to the number of milliseconds since the + * Unix epoch (1970-01-01 00:00:00 UTC). + * + * ```kotlin + * // Convert the 'timestamp' field to milliseconds since epoch. + * timestampToUnixMillis("timestamp") + * ``` + * + * @param fieldName The name of the field that contains the timestamp. + * @return A new [Expression] representing the number of milliseconds since epoch. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampToUnixMillis(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that interprets an expression as the number of seconds since the Unix + * epoch (1970-01-01 00:00:00 UTC) and returns a timestamp. + * + * ```kotlin + * // Interpret the 'seconds' field as seconds since epoch. + * unixSecondsToTimestamp(field("seconds")) + * ``` + * + * @param expr The expression representing the number of seconds since epoch. + * @return A new [Expression] representing the timestamp. + */ + +public com.google.firebase.firestore.pipeline.Expression unixSecondsToTimestamp(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that interprets a field's value as the number of seconds since the Unix + * epoch (1970-01-01 00:00:00 UTC) and returns a timestamp. + * + * ```kotlin + * // Interpret the 'seconds' field as seconds since epoch. + * unixSecondsToTimestamp("seconds") + * ``` + * + * @param fieldName The name of the field containing the number of seconds since epoch. + * @return A new [Expression] representing the timestamp. + */ + +public com.google.firebase.firestore.pipeline.Expression unixSecondsToTimestamp(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that converts a timestamp expression to the number of seconds since the + * Unix epoch (1970-01-01 00:00:00 UTC). + * + * ```kotlin + * // Convert the 'timestamp' field to seconds since epoch. + * timestampToUnixSeconds(field("timestamp")) + * ``` + * + * @param expr The expression representing the timestamp. + * @return A new [Expression] representing the number of seconds since epoch. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampToUnixSeconds(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that converts a timestamp field to the number of seconds since the Unix + * epoch (1970-01-01 00:00:00 UTC). + * + * ```kotlin + * // Convert the 'timestamp' field to seconds since epoch. + * timestampToUnixSeconds("timestamp") + * ``` + * + * @param fieldName The name of the field that contains the timestamp. + * @return A new [Expression] representing the number of seconds since epoch. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampToUnixSeconds(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that adds a specified amount of time to a timestamp. + * + * ```kotlin + * // Add some duration determined by field 'unit' and 'amount' to the 'timestamp' field. + * timestampAdd(field("timestamp"), field("unit"), field("amount")) + * ``` + * + * @param timestamp The expression representing the timestamp. + * @param unit The expression representing the unit of time to add. Valid units include + * "microsecond", "millisecond", "second", "minute", "hour" and "day". + * @param amount The expression representing the amount of time to add. + * @return A new [Expression] representing the resulting timestamp. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampAdd(com.google.firebase.firestore.pipeline.Expression timestamp, com.google.firebase.firestore.pipeline.Expression unit, com.google.firebase.firestore.pipeline.Expression amount) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that adds a specified amount of time to a timestamp. + * + * ```kotlin + * // Add 1 day to the 'timestamp' field. + * timestampAdd(field("timestamp"), "day", 1) + * ``` + * + * @param timestamp The expression representing the timestamp. + * @param unit The unit of time to add. Valid units include "microsecond", "millisecond", + * "second", "minute", "hour" and "day". + * @param amount The amount of time to add. + * @return A new [Expression] representing the resulting timestamp. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampAdd(com.google.firebase.firestore.pipeline.Expression timestamp, java.lang.String unit, long amount) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that adds a specified amount of time to a timestamp. + * + * ```kotlin + * // Add some duration determined by field 'unit' and 'amount' to the 'timestamp' field. + * timestampAdd("timestamp", field("unit"), field("amount")) + * ``` + * + * @param fieldName The name of the field that contains the timestamp. + * @param unit The expression representing the unit of time to add. Valid units include + * "microsecond", "millisecond", "second", "minute", "hour" and "day". + * @param amount The expression representing the amount of time to add. + * @return A new [Expression] representing the resulting timestamp. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampAdd(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression unit, com.google.firebase.firestore.pipeline.Expression amount) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that adds a specified amount of time to a timestamp. + * + * ```kotlin + * // Add 1 day to the 'timestamp' field. + * timestampAdd("timestamp", "day", 1) + * ``` + * + * @param fieldName The name of the field that contains the timestamp. + * @param unit The unit of time to add. Valid units include "microsecond", "millisecond", + * "second", "minute", "hour" and "day". + * @param amount The amount of time to add. + * @return A new [Expression] representing the resulting timestamp. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampAdd(java.lang.String fieldName, java.lang.String unit, long amount) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that subtracts a specified amount of time to a timestamp. + * + * ```kotlin + * // Subtract some duration determined by field 'unit' and 'amount' from the 'timestamp' field. + * timestampSubtract(field("timestamp"), field("unit"), field("amount")) + * ``` + * + * @param timestamp The expression representing the timestamp. + * @param unit The expression representing the unit of time to subtract. Valid units include + * "microsecond", "millisecond", "second", "minute", "hour" and "day". + * @param amount The expression representing the amount of time to subtract. + * @return A new [Expression] representing the resulting timestamp. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampSubtract(com.google.firebase.firestore.pipeline.Expression timestamp, com.google.firebase.firestore.pipeline.Expression unit, com.google.firebase.firestore.pipeline.Expression amount) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that subtracts a specified amount of time to a timestamp. + * + * ```kotlin + * // Subtract 1 day from the 'timestamp' field. + * timestampSubtract(field("timestamp"), "day", 1) + * ``` + * + * @param timestamp The expression representing the timestamp. + * @param unit The unit of time to subtract. Valid units include "microsecond", "millisecond", + * "second", "minute", "hour" and "day". + * @param amount The amount of time to subtract. + * @return A new [Expression] representing the resulting timestamp. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampSubtract(com.google.firebase.firestore.pipeline.Expression timestamp, java.lang.String unit, long amount) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that subtracts a specified amount of time to a timestamp. + * + * ```kotlin + * // Subtract some duration determined by field 'unit' and 'amount' from the 'timestamp' field. + * timestampSubtract("timestamp", field("unit"), field("amount")) + * ``` + * + * @param fieldName The name of the field that contains the timestamp. + * @param unit The unit of time to subtract. Valid units include "microsecond", "millisecond", + * "second", "minute", "hour" and "day". + * @param amount The amount of time to subtract. + * @return A new [Expression] representing the resulting timestamp. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampSubtract(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression unit, com.google.firebase.firestore.pipeline.Expression amount) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that subtracts a specified amount of time to a timestamp. + * + * ```kotlin + * // Subtract 1 day from the 'timestamp' field. + * timestampSubtract("timestamp", "day", 1) + * ``` + * + * @param fieldName The name of the field that contains the timestamp. + * @param unit The unit of time to subtract. Valid units include "microsecond", "millisecond", + * "second", "minute", "hour" and "day". + * @param amount The amount of time to subtract. + * @return A new [Expression] representing the resulting timestamp. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampSubtract(java.lang.String fieldName, java.lang.String unit, long amount) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates a timestamp to a specified granularity. + * + * ```kotlin + * // Truncate the 'createdAt' timestamp to the beginning of the day. + * timestampTruncate(field("createdAt"), "day") + * ``` + * + * @param timestamp The timestamp expression. + * @param granularity The granularity to truncate to. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @return A new [Expression] representing the truncated timestamp. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampTruncate(com.google.firebase.firestore.pipeline.Expression timestamp, java.lang.String granularity) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates a timestamp to a specified granularity. + * + * ```kotlin + * // Truncate the 'createdAt' timestamp to the beginning of the day. + * timestampTruncate(field("createdAt"), field("granularity")) + * ``` + * + * @param timestamp The timestamp expression. + * @param granularity The granularity expression to truncate to. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @return A new [Expression] representing the truncated timestamp. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampTruncate(com.google.firebase.firestore.pipeline.Expression timestamp, com.google.firebase.firestore.pipeline.Expression granularity) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates a timestamp to a specified granularity. + * + * ```kotlin + * // Truncate the 'createdAt' timestamp to the beginning of the day. + * timestampTruncate("createdAt", "day") + * ``` + * + * @param fieldName The name of the field containing the timestamp. + * @param granularity The granularity to truncate to. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @return A new [Expression] representing the truncated timestamp. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampTruncate(java.lang.String fieldName, java.lang.String granularity) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates a timestamp to a specified granularity. + * + * ```kotlin + * // Truncate the 'createdAt' timestamp to the beginning of the day. + * timestampTruncate("createdAt", field("granularity")) + * ``` + * + * @param fieldName The name of the field containing the timestamp. + * @param granularity The granularity expression to truncate to. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @return A new [Expression] representing the truncated timestamp. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampTruncate(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression granularity) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates a timestamp to a specified granularity in a given + * timezone. + * + * ```kotlin + * // Truncate the 'createdAt' timestamp to the beginning of the day in "America/Los_Angeles" + * // timezone. + * timestampTruncateWithTimezone(field("createdAt"), "day", "America/Los_Angeles") + * ``` + * + * @param timestamp The timestamp expression. + * @param granularity The granularity to truncate to. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone to use for truncation. Valid values are from the TZ database + * (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". + * @return A new [Expression] representing the truncated timestamp. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(com.google.firebase.firestore.pipeline.Expression timestamp, java.lang.String granularity, java.lang.String timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates a timestamp to a specified granularity in a given + * timezone. + * + * ```kotlin + * // Truncate the 'createdAt' timestamp to the beginning of the day in "America/Los_Angeles" + * // timezone. + * timestampTruncateWithTimezone(field("createdAt"), field("granularity"), "America/Los_Angeles") + * ``` + * + * @param timestamp The timestamp expression. + * @param granularity The granularity expression to truncate to. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone to use for truncation. Valid values are from the TZ database + * (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". + * @return A new [Expression] representing the truncated timestamp. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(com.google.firebase.firestore.pipeline.Expression timestamp, com.google.firebase.firestore.pipeline.Expression granularity, java.lang.String timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates a timestamp to a specified granularity in a given + * timezone. + * + * ```kotlin + * // Truncate the 'createdAt' timestamp to the beginning of the day in "America/Los_Angeles" + * // timezone. + * timestampTruncateWithTimezone("createdAt", "day", "America/Los_Angeles") + * ``` + * + * @param fieldName The name of the field containing the timestamp. + * @param granularity The granularity to truncate to. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone to use for truncation. Valid values are from the TZ database + * (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". + * @return A new [Expression] representing the truncated timestamp. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(java.lang.String fieldName, java.lang.String granularity, java.lang.String timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates a timestamp to a specified granularity in a given + * timezone. + * + * ```kotlin + * // Truncate the 'createdAt' timestamp to the beginning of the day in "America/Los_Angeles" + * // timezone. + * timestampTruncateWithTimezone("createdAt", field("granularity"), "America/Los_Angeles") + * ``` + * + * @param fieldName The name of the field containing the timestamp. + * @param granularity The granularity expression to truncate to. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone to use for truncation. Valid values are from the TZ database + * (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". + * @return A new [Expression] representing the truncated timestamp. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression granularity, java.lang.String timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates a timestamp to a specified granularity in a given + * timezone. + * + * ```kotlin + * // Truncate the 'createdAt' timestamp to the beginning of the day in timezone specified by + * // the 'tz' field. + * timestampTruncateWithTimezone(field("createdAt"), "day", field("tz")) + * ``` + * + * @param timestamp The timestamp expression. + * @param granularity The granularity to truncate to. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone expression to use for truncation. Valid values are from the TZ + * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". + * @return A new [Expression] representing the truncated timestamp. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(com.google.firebase.firestore.pipeline.Expression timestamp, java.lang.String granularity, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates a timestamp to a specified granularity in a given + * timezone. + * + * ```kotlin + * // Truncate the 'createdAt' timestamp to the beginning of the day in timezone specified by + * // the 'tz' field. + * timestampTruncateWithTimezone(field("createdAt"), field("granularity"), field("tz")) + * ``` + * + * @param timestamp The timestamp expression. + * @param granularity The granularity expression to truncate to. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone expression to use for truncation. Valid values are from the TZ + * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". + * @return A new [Expression] representing the truncated timestamp. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(com.google.firebase.firestore.pipeline.Expression timestamp, com.google.firebase.firestore.pipeline.Expression granularity, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates a timestamp to a specified granularity in a given + * timezone. + * + * ```kotlin + * // Truncate the 'createdAt' timestamp to the beginning of the day in timezone specified by + * // the 'tz' field. + * timestampTruncateWithTimezone("createdAt", "day", field("tz")) + * ``` + * + * @param fieldName The name of the field containing the timestamp. + * @param granularity The granularity to truncate to. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone expression to use for truncation. Valid values are from the TZ + * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". + * @return A new [Expression] representing the truncated timestamp. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(java.lang.String fieldName, java.lang.String granularity, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that truncates a timestamp to a specified granularity in a given + * timezone. + * + * ```kotlin + * // Truncate the 'createdAt' timestamp to the beginning of the day in timezone specified by + * // the 'tz' field. + * timestampTruncateWithTimezone("createdAt", field("granularity"), field("tz")) + * ``` + * + * @param fieldName The name of the field containing the timestamp. + * @param granularity The granularity expression to truncate to. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", + * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", + * "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone expression to use for truncation. Valid values are from the TZ + * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". + * @return A new [Expression] representing the truncated timestamp. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression granularity, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the difference between two timestamps. + * + * ```kotlin + * // Calculate the difference between the fields 'endAt' and the field 'startAt' in unit specified by + * // the 'unit' field. + * timestampDiff(field("endAt"), field("startAt"), field("unit")) + * ``` + * + * @param end The ending timestamp expression. + * @param start The starting timestamp expression. + * @param unit The unit of time for the difference. Valid values include "microsecond", + * "millisecond", "second", "minute", "hour" and "day". + * @return A new [Expression] representing the difference. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampDiff(com.google.firebase.firestore.pipeline.Expression end, com.google.firebase.firestore.pipeline.Expression start, com.google.firebase.firestore.pipeline.Expression unit) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the difference between two timestamps. + * + * ```kotlin + * // Calculate the difference in days between 'endAt' field and 'startAt' field. + * timestampDiff(field("endAt"), field("startAt"), "day") + * ``` + * + * @param end The ending timestamp expression. + * @param start The starting timestamp expression. + * @param unit The unit of time for the difference. Valid values include "microsecond", + * "millisecond", "second", "minute", "hour" and "day". + * @return A new [Expression] representing the difference. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampDiff(com.google.firebase.firestore.pipeline.Expression end, com.google.firebase.firestore.pipeline.Expression start, java.lang.String unit) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the difference between two timestamps. + * + * ```kotlin + * // Calculate the difference in days between 'endAt' and 'startAt'. + * timestampDiff("endAt", "startAt", "day") + * ``` + * + * @param endFieldName The ending timestamp field name. + * @param startFieldName The starting timestamp field name. + * @param unit The unit of time for the difference. Valid values include "microsecond", + * "millisecond", "second", "minute", "hour" and "day". + * @return A new [Expression] representing the difference. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampDiff(java.lang.String endFieldName, java.lang.String startFieldName, java.lang.String unit) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the difference between two timestamps. + * + * ```kotlin + * // Calculate the difference in days between 'endAt' and 'startAt'. + * timestampDiff("endAt", field("startAt"), "day") + * ``` + * + * @param endFieldName The ending timestamp field name. + * @param start The starting timestamp expression. + * @param unit The unit of time for the difference. Valid values include "microsecond", + * "millisecond", "second", "minute", "hour" and "day". + * @return A new [Expression] representing the difference. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampDiff(java.lang.String endFieldName, com.google.firebase.firestore.pipeline.Expression start, java.lang.String unit) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the difference between two timestamps. + * + * ```kotlin + * // Calculate the difference in days between 'endAt' and 'startAt'. + * timestampDiff(field("endAt"), "startAt", "day") + * ``` + * + * @param end The ending timestamp expression. + * @param startFieldName The starting timestamp field name. + * @param unit The unit of time for the difference. Valid values include "microsecond", + * "millisecond", "second", "minute", "hour" and "day". + * @return A new [Expression] representing the difference. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampDiff(com.google.firebase.firestore.pipeline.Expression end, java.lang.String startFieldName, java.lang.String unit) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that extracts a specified part from a timestamp. + * + * ```kotlin + * // Extract the part specified by the field 'part' from 'createdAt'. + * timestampExtract(field("createdAt"), field("part")) + * ``` + * + * @param timestamp The timestamp expression. + * @param part The part to extract from the timestamp. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", + * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", + * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". + * @return A new [Expression] representing the extracted part. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampExtract(com.google.firebase.firestore.pipeline.Expression timestamp, com.google.firebase.firestore.pipeline.Expression part) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that extracts a specified part from a timestamp. + * + * ```kotlin + * // Extract the day from the timestamp returned by the expression. + * timestampExtract(field("createdAt"), "day") + * ``` + * + * @param timestamp The timestamp expression. + * @param part The part to extract from the timestamp. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", + * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", + * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". + * @return A new [Expression] representing the extracted part. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampExtract(com.google.firebase.firestore.pipeline.Expression timestamp, java.lang.String part) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that extracts a specified part from a timestamp. + * + * ```kotlin + * // Extract the part specified by the field 'part' from 'createdAt'. + * timestampExtract("createdAt", field("part")) + * ``` + * + * @param fieldName The name of the field containing the timestamp. + * @param part The part to extract from the timestamp. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", + * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", + * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". + * @return A new [Expression] representing the extracted part. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampExtract(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression part) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that extracts a specified part from a timestamp. + * + * ```kotlin + * // Extract the day from the timestamp in the 'createdAt' field. + * timestampExtract("createdAt", "day") + * ``` + * + * @param fieldName The name of the field containing the timestamp. + * @param part The part to extract from the timestamp. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", + * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", + * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". + * @return A new [Expression] representing the extracted part. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampExtract(java.lang.String fieldName, java.lang.String part) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that extracts a specified part from a timestamp in a given timezone. + * + * ```kotlin + * // Extract the part specified by the field 'part' from 'createdAt' in the timezone specified by + * // the field 'tz'. + * timestampExtractWithTimezone(field("createdAt"), field("part"), field("tz")) + * ``` + * + * @param timestamp The timestamp expression. + * @param part The part to extract from the timestamp. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", + * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", + * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone expression to use for extraction.Valid values are from the TZ + * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not + * specified. + * @return A new [Expression] representing the extracted part. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(com.google.firebase.firestore.pipeline.Expression timestamp, com.google.firebase.firestore.pipeline.Expression part, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that extracts a specified part from a timestamp in a given timezone. + * + * ```kotlin + * // Extract the part specified by the field 'part' from 'createdAt' in the timezone "America/Los_Angeles". + * timestampExtractWithTimezone(field("createdAt"), field("part"), "America/Los_Angeles") + * ``` + * + * @param timestamp The timestamp expression. + * @param part The part to extract from the timestamp. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", + * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", + * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone expression to use for extraction.Valid values are from the TZ + * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not + * specified. + * @return A new [Expression] representing the extracted part. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(com.google.firebase.firestore.pipeline.Expression timestamp, com.google.firebase.firestore.pipeline.Expression part, java.lang.String timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that extracts a specified part from a timestamp in a given timezone. + * + * ```kotlin + * // Extract the day from the timestamp in the 'createdAt' field in the timezone "America/Los_Angeles". + * timestampExtractWithTimezone(field("createdAt"), "day", "America/Los_Angeles") + * ``` + * + * @param timestamp The timestamp expression. + * @param part The part to extract from the timestamp. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", + * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", + * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone expression to use for extraction.Valid values are from the TZ + * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not + * specified. + * @return A new [Expression] representing the extracted part. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(com.google.firebase.firestore.pipeline.Expression timestamp, java.lang.String part, java.lang.String timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that extracts a specified part from a timestamp in a given timezone. + * + * ```kotlin + * // Extract the part specified by the field 'part' from 'createdAt' in the timezone "America/Los_Angeles". + * timestampExtractWithTimezone("createdAt", field("part"), "America/Los_Angeles") + * ``` + * + * @param fieldName The name of the field containing the timestamp. + * @param part The part to extract from the timestamp. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", + * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", + * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone expression to use for extraction.Valid values are from the TZ + * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not + * specified. + * @return A new [Expression] representing the extracted part. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression part, java.lang.String timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that extracts a specified part from a timestamp in a given timezone. + * + * ```kotlin + * // Extract the day from the timestamp in the 'createdAt' field in the timezone "America/Los_Angeles". + * timestampExtractWithTimezone("createdAt", "day", "America/Los_Angeles") + * ``` + * + * @param fieldName The name of the field containing the timestamp. + * @param part The part to extract from the timestamp. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", + * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", + * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone expression to use for extraction.Valid values are from the TZ + * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not + * specified. + * @return A new [Expression] representing the extracted part. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(java.lang.String fieldName, java.lang.String part, java.lang.String timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that extracts a specified part from a timestamp in a given timezone. + * + * ```kotlin + * // Extract the day from the timestamp in the 'createdAt' field in the timezone specified by the 'tz' field. + * timestampExtractWithTimezone(field("createdAt"), "day", field("tz")) + * ``` + * + * @param timestamp The timestamp expression. + * @param part The part to extract from the timestamp. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", + * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", + * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone expression to use for extraction.Valid values are from the TZ + * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not + * specified. + * @return A new [Expression] representing the extracted part. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(com.google.firebase.firestore.pipeline.Expression timestamp, java.lang.String part, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that extracts a specified part from a timestamp in a given timezone. + * + * ```kotlin + * // Extract the part specified by the field 'part' from 'createdAt' in the timezone specified by the 'tz' field. + * timestampExtractWithTimezone("createdAt", field("part"), field("tz")) + * ``` + * + * @param fieldName The name of the field containing the timestamp. + * @param part The part to extract from the timestamp. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", + * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", + * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone expression to use for extraction.Valid values are from the TZ + * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not + * specified. + * @return A new [Expression] representing the extracted part. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression part, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that extracts a specified part from a timestamp in a given timezone. + * + * ```kotlin + * // Extract the day from the timestamp in the 'createdAt' field in the timezone specified by the 'tz' field. + * timestampExtractWithTimezone("createdAt", "day", field("tz")) + * ``` + * + * @param fieldName The name of the field containing the timestamp. + * @param part The part to extract from the timestamp. Valid values are "microsecond", + * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", + * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", + * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". + * @param timezone The timezone expression to use for extraction.Valid values are from the TZ + * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not + * specified. + * @return A new [Expression] representing the extracted part. + */ + +public com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(java.lang.String fieldName, java.lang.String part, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if two expressions are equal. + * + * ```kotlin + * // Check if the 'age' field is equal to an expression + * equal(field("age"), field("minAge").add(10)) + * ``` + * + * @param left The first expression to compare. + * @param right The second expression to compare to. + * @return A new [BooleanExpression] representing the equality comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression equal(com.google.firebase.firestore.pipeline.Expression left, com.google.firebase.firestore.pipeline.Expression right) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if an expression is equal to a value. + * + * ```kotlin + * // Check if the 'age' field is equal to 21 + * equal(field("age"), 21) + * ``` + * + * @param left The first expression to compare. + * @param right The value to compare to. + * @return A new [BooleanExpression] representing the equality comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression equal(com.google.firebase.firestore.pipeline.Expression left, java.lang.Object right) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field's value is equal to an expression. + * + * ```kotlin + * // Check if the 'age' field is equal to the 'limit' field + * equal("age", field("limit")) + * ``` + * + * @param fieldName The field name to compare. + * @param expression The expression to compare to. + * @return A new [BooleanExpression] representing the equality comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression equal(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field's value is equal to another value. + * + * ```kotlin + * // Check if the 'city' field is equal to string constant "London" + * equal("city", "London") + * ``` + * + * @param fieldName The field name to compare. + * @param value The value to compare to. + * @return A new [BooleanExpression] representing the equality comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression equal(java.lang.String fieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if two expressions are not equal. + * + * ```kotlin + * // Check if the 'status' field is not equal to the value of the 'otherStatus' field + * notEqual(field("status"), field("otherStatus")) + * ``` + * + * @param left The first expression to compare. + * @param right The second expression to compare to. + * @return A new [BooleanExpression] representing the inequality comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression notEqual(com.google.firebase.firestore.pipeline.Expression left, com.google.firebase.firestore.pipeline.Expression right) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if an expression is not equal to a value. + * + * ```kotlin + * // Check if the 'status' field is not equal to "completed" + * notEqual(field("status"), "completed") + * ``` + * + * @param left The first expression to compare. + * @param right The value to compare to. + * @return A new [BooleanExpression] representing the inequality comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression notEqual(com.google.firebase.firestore.pipeline.Expression left, java.lang.Object right) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field's value is not equal to an expression. + * + * ```kotlin + * // Check if the 'status' field is not equal to the value of the 'otherStatus' field + * notEqual("status", field("otherStatus")) + * ``` + * + * @param fieldName The field name to compare. + * @param expression The expression to compare to. + * @return A new [BooleanExpression] representing the inequality comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression notEqual(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field's value is not equal to another value. + * + * ```kotlin + * // Check if the 'status' field is not equal to "completed" + * notEqual("status", "completed") + * + * // Check if the 'country' field is not equal to "USA" + * notEqual("country", "USA") + * ``` + * + * @param fieldName The field name to compare. + * @param value The value to compare to. + * @return A new [BooleanExpression] representing the inequality comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression notEqual(java.lang.String fieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if the first expression is greater than the second + * expression. + * + * ```kotlin + * // Check if the 'age' field is greater than the 'limit' field + * greaterThan(field("age"), field("limit")) + * ``` + * + * @param left The first expression to compare. + * @param right The second expression to compare to. + * @return A new [BooleanExpression] representing the greater than comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression greaterThan(com.google.firebase.firestore.pipeline.Expression left, com.google.firebase.firestore.pipeline.Expression right) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if an expression is greater than a value. + * + * ```kotlin + * // Check if the 'price' field is greater than 100 + * greaterThan(field("price"), 100) + * ``` + * + * @param left The first expression to compare. + * @param right The value to compare to. + * @return A new [BooleanExpression] representing the greater than comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression greaterThan(com.google.firebase.firestore.pipeline.Expression left, java.lang.Object right) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field's value is greater than an expression. + * + * ```kotlin + * // Check if the 'age' field is greater than the 'limit' field + * greaterThan("age", field("limit")) + * ``` + * + * @param fieldName The field name to compare. + * @param expression The expression to compare to. + * @return A new [BooleanExpression] representing the greater than comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression greaterThan(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field's value is greater than another value. + * + * ```kotlin + * // Check if the 'price' field is greater than 100 + * greaterThan("price", 100) + * ``` + * + * @param fieldName The field name to compare. + * @param value The value to compare to. + * @return A new [BooleanExpression] representing the greater than comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression greaterThan(java.lang.String fieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if the first expression is greater than or equal to the + * second expression. + * + * ```kotlin + * // Check if the 'quantity' field is greater than or equal to field 'requirement' plus 1 + * greaterThanOrEqual(field("quantity"), field("requirement").add(1)) + * ``` + * + * @param left The first expression to compare. + * @param right The second expression to compare to. + * @return A new [BooleanExpression] representing the greater than or equal to comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression greaterThanOrEqual(com.google.firebase.firestore.pipeline.Expression left, com.google.firebase.firestore.pipeline.Expression right) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if an expression is greater than or equal to a value. + * + * ```kotlin + * // Check if the 'score' field is greater than or equal to 80 + * greaterThanOrEqual(field("score"), 80) + * ``` + * + * @param left The first expression to compare. + * @param right The value to compare to. + * @return A new [BooleanExpression] representing the greater than or equal to comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression greaterThanOrEqual(com.google.firebase.firestore.pipeline.Expression left, java.lang.Object right) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field's value is greater than or equal to an + * expression. + * + * ```kotlin + * // Check if the 'quantity' field is greater than or equal to field 'requirement' plus 1 + * greaterThanOrEqual("quantity", field("requirement").add(1)) + * ``` + * + * @param fieldName The field name to compare. + * @param expression The expression to compare to. + * @return A new [BooleanExpression] representing the greater than or equal to comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression greaterThanOrEqual(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field's value is greater than or equal to another + * value. + * + * ```kotlin + * // Check if the 'score' field is greater than or equal to 80 + * greaterThanOrEqual("score", 80) + * ``` + * + * @param fieldName The field name to compare. + * @param value The value to compare to. + * @return A new [BooleanExpression] representing the greater than or equal to comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression greaterThanOrEqual(java.lang.String fieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if the first expression is less than the second expression. + * + * ```kotlin + * // Check if the 'age' field is less than 'limit' + * lessThan(field("age"), field("limit")) + * ``` + * + * @param left The first expression to compare. + * @param right The second expression to compare to. + * @return A new [BooleanExpression] representing the less than comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression lessThan(com.google.firebase.firestore.pipeline.Expression left, com.google.firebase.firestore.pipeline.Expression right) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if an expression is less than a value. + * + * ```kotlin + * // Check if the 'price' field is less than 50 + * lessThan(field("price"), 50) + * ``` + * + * @param left The first expression to compare. + * @param right The value to compare to. + * @return A new [BooleanExpression] representing the less than comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression lessThan(com.google.firebase.firestore.pipeline.Expression left, java.lang.Object right) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field's value is less than an expression. + * + * ```kotlin + * // Check if the 'age' field is less than 'limit' + * lessThan("age", field("limit")) + * ``` + * + * @param fieldName The field name to compare. + * @param expression The expression to compare to. + * @return A new [BooleanExpression] representing the less than comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression lessThan(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field's value is less than another value. + * + * ```kotlin + * // Check if the 'price' field is less than 50 + * lessThan("price", 50) + * ``` + * + * @param fieldName The field name to compare. + * @param value The value to compare to. + * @return A new [BooleanExpression] representing the less than comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression lessThan(java.lang.String fieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if the first expression is less than or equal to the second + * expression. + * + * ```kotlin + * // Check if the 'quantity' field is less than or equal to 20 + * lessThanOrEqual(field("quantity"), constant(20)) + * ``` + * + * @param left The first expression to compare. + * @param right The second expression to compare to. + * @return A new [BooleanExpression] representing the less than or equal to comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression lessThanOrEqual(com.google.firebase.firestore.pipeline.Expression left, com.google.firebase.firestore.pipeline.Expression right) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if an expression is less than or equal to a value. + * + * ```kotlin + * // Check if the 'score' field is less than or equal to 70 + * lessThanOrEqual(field("score"), 70) + * ``` + * + * @param left The first expression to compare. + * @param right The value to compare to. + * @return A new [BooleanExpression] representing the less than or equal to comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression lessThanOrEqual(com.google.firebase.firestore.pipeline.Expression left, java.lang.Object right) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field's value is less than or equal to an expression. + * + * ```kotlin + * // Check if the 'quantity' field is less than or equal to 20 + * lessThanOrEqual("quantity", constant(20)) + * ``` + * + * @param fieldName The field name to compare. + * @param expression The expression to compare to. + * @return A new [BooleanExpression] representing the less than or equal to comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression lessThanOrEqual(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field's value is less than or equal to another value. + * + * ```kotlin + * // Check if the 'score' field is less than or equal to 70 + * lessThanOrEqual("score", 70) + * ``` + * + * @param fieldName The field name to compare. + * @param value The value to compare to. + * @return A new [BooleanExpression] representing the less than or equal to comparison. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression lessThanOrEqual(java.lang.String fieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that concatenates strings, arrays, or blobs. Types cannot be mixed. + * + * ```kotlin + * // Concatenate the 'firstName' and 'lastName' fields with a space in between. + * concat(field("firstName"), " ", field("lastName")) + * ``` + * + * @param first The first expression to concatenate. + * @param second The second expression to concatenate. + * @param others Additional expressions to concatenate. + * @return A new [Expression] representing the concatenation. + */ + +public com.google.firebase.firestore.pipeline.Expression concat(com.google.firebase.firestore.pipeline.Expression first, com.google.firebase.firestore.pipeline.Expression second, java.lang.Object... others) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that concatenates strings, arrays, or blobs. Types cannot be mixed. + * + * ```kotlin + * // Concatenate a field with a literal string. + * concat(field("firstName"), "Doe") + * ``` + * + * @param first The first expression to concatenate. + * @param second The second value to concatenate. + * @param others Additional values to concatenate. + * @return A new [Expression] representing the concatenation. + */ + +public com.google.firebase.firestore.pipeline.Expression concat(com.google.firebase.firestore.pipeline.Expression first, java.lang.Object second, java.lang.Object... others) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that concatenates strings, arrays, or blobs. Types cannot be mixed. + * + * ```kotlin + * // Concatenate a field name with an expression. + * concat("firstName", field("lastName")) + * ``` + * + * @param first The name of the field containing the first value to concatenate. + * @param second The second expression to concatenate. + * @param others Additional expressions to concatenate. + * @return A new [Expression] representing the concatenation. + */ + +public com.google.firebase.firestore.pipeline.Expression concat(java.lang.String first, com.google.firebase.firestore.pipeline.Expression second, java.lang.Object... others) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that concatenates strings, arrays, or blobs. Types cannot be mixed. + * + * ```kotlin + * // Concatenate a field name with a literal string. + * concat("firstName", "Doe") + * ``` + * + * @param first The name of the field containing the first value to concatenate. + * @param second The second value to concatenate. + * @param others Additional values to concatenate. + * @return A new [Expression] representing the concatenation. + */ + +public com.google.firebase.firestore.pipeline.Expression concat(java.lang.String first, java.lang.Object second, java.lang.Object... others) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that creates a Firestore array value from an input array. + * + * ```kotlin + * // Create an array of numbers + * array(1, 2, 3) + * + * // Create an array containing a field value and a constant + * array(field("quantity"), 10) + * ``` + * + * @param elements The input array to evaluate in the expression. + * @return A new [Expression] representing the array function. + */ + +public com.google.firebase.firestore.pipeline.Expression array(java.lang.Object... elements) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that creates a Firestore array value from an input array. + * + * @param elements The input array to evaluate in the expression. + * @return A new [Expression] representing the array function. + */ + +public com.google.firebase.firestore.pipeline.Expression array(java.util.List elements) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that concatenates an array with other arrays. + * + * ```kotlin + * // Combine the 'items' array with another array field. + * arrayConcat(field("items"), field("otherItems")) + * ``` + * + * @param firstArray The first array expression to concatenate to. + * @param secondArray An expression that evaluates to array to concatenate. + * @param otherArrays Optional additional array expressions or array literals to concatenate. + * @return A new [Expression] representing the arrayConcat operation. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayConcat(com.google.firebase.firestore.pipeline.Expression firstArray, com.google.firebase.firestore.pipeline.Expression secondArray, java.lang.Object... otherArrays) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that concatenates an array with other arrays. + * + * ```kotlin + * // Combine the 'items' array with another array field. + * arrayConcat(field("items"), field("otherItems")) + * ``` + * + * @param firstArray The first array expression to concatenate to. + * @param secondArray An array expression or array literal to concatenate. + * @param otherArrays Optional additional array expressions or array literals to concatenate. + * @return A new [Expression] representing the arrayConcat operation. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayConcat(com.google.firebase.firestore.pipeline.Expression firstArray, java.lang.Object secondArray, java.lang.Object... otherArrays) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that concatenates a field's array value with other arrays. + * + * ```kotlin + * // Combine the 'items' array with another array field. + * arrayConcat("items", field("otherItems")) + * ``` + * + * @param firstArrayField The name of field that contains first array to concatenate to. + * @param secondArray An expression that evaluates to array to concatenate. + * @param otherArrays Optional additional array expressions or array literals to concatenate. + * @return A new [Expression] representing the arrayConcat operation. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayConcat(java.lang.String firstArrayField, com.google.firebase.firestore.pipeline.Expression secondArray, java.lang.Object... otherArrays) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that concatenates a field's array value with other arrays. + * + * ```kotlin + * // Combine the 'items' array with a literal array. + * arrayConcat("items", listOf("a", "b")) + * ``` + * + * @param firstArrayField The name of field that contains first array to concatenate to. + * @param secondArray An array expression or array literal to concatenate. + * @param otherArrays Optional additional array expressions or array literals to concatenate. + * @return A new [Expression] representing the arrayConcat operation. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayConcat(java.lang.String firstArrayField, java.lang.Object secondArray, java.lang.Object... otherArrays) { throw new RuntimeException("Stub!"); } + +/** + * Reverses the order of elements in the [array]. + * + * ```kotlin + * // Reverse the value of the 'myArray' field. + * arrayReverse(field("myArray")) + * ``` + * + * @param array The array expression to reverse. + * @return A new [Expression] representing the arrayReverse operation. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayReverse(com.google.firebase.firestore.pipeline.Expression array) { throw new RuntimeException("Stub!"); } + +/** + * Reverses the order of elements in the array field. + * + * ```kotlin + * // Reverse the value of the 'myArray' field. + * arrayReverse("myArray") + * ``` + * + * @param arrayFieldName The name of field that contains the array to reverse. + * @return A new [Expression] representing the arrayReverse operation. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayReverse(java.lang.String arrayFieldName) { throw new RuntimeException("Stub!"); } + +/** + * Filters an [array] expression based on a predicate. + * + * ```kotlin + * // Filter 'scores' array to include only values greater than 50 + * arrayFilter(field("scores"), "score", greaterThan(variable("score"), 50)) + * ``` + * + * @param array The array expression to filter. + * @param alias The alias to use for the current element in the filter expression. + * @param filter The predicate boolean expression used to filter the elements. + * @return A new [Expression] representing the arrayFilter operation. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayFilter(com.google.firebase.firestore.pipeline.Expression array, java.lang.String alias, com.google.firebase.firestore.pipeline.BooleanExpression filter) { throw new RuntimeException("Stub!"); } + +/** + * Filters an array field based on a predicate. + * + * ```kotlin + * // Filter 'scores' array to include only values greater than 50 + * arrayFilter("scores", "score", greaterThan(variable("score"), 50)) + * ``` + * + * @param arrayFieldName The name of field that contains array to filter. + * @param alias The alias to use for the current element in the filter expression. + * @param filter The predicate boolean expression used to filter the elements. + * @return A new [Expression] representing the arrayFilter operation. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayFilter(java.lang.String arrayFieldName, java.lang.String alias, com.google.firebase.firestore.pipeline.BooleanExpression filter) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a provided transformation to each element in an array. + * + * ```kotlin + * // Transform 'scores' array by multiplying each score by 10 + * arrayTransform(field("scores"), "score", multiply(variable("score"), 10)) + * ``` + * + * @param array The array expression to transform. + * @param elementAlias The alias to use for the current element in the transform expression. + * @param transform The expression used to transform the elements. + * @return A new [Expression] representing the arrayTransform operation. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayTransform(com.google.firebase.firestore.pipeline.Expression array, java.lang.String elementAlias, com.google.firebase.firestore.pipeline.Expression transform) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a provided transformation to each element in an array. + * + * ```kotlin + * // Transform 'scores' array by multiplying each score by 10 + * arrayTransform("scores", "score", multiply(variable("score"), 10)) + * ``` + * + * @param arrayFieldName The name of field that contains array to transform. + * @param elementAlias The alias to use for the current element in the transform expression. + * @param transform The expression used to transform the elements. + * @return A new [Expression] representing the arrayTransform operation. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayTransform(java.lang.String arrayFieldName, java.lang.String elementAlias, com.google.firebase.firestore.pipeline.Expression transform) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a provided transformation to each element in an array, + * providing the element's index to the transformation expression. + * + * ```kotlin + * // Transform 'scores' array by adding the index + * arrayTransformWithIndex(field("scores"), "score", "i", add(variable("score"), variable("i"))) + * ``` + * + * @param array The array expression to transform. + * @param elementAlias The alias to use for the current element in the transform expression. + * @param indexAlias The alias to use for the current index. + * @param transform The expression used to transform the elements. + * @return A new [Expression] representing the arrayTransformWithIndex operation. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayTransformWithIndex(com.google.firebase.firestore.pipeline.Expression array, java.lang.String elementAlias, java.lang.String indexAlias, com.google.firebase.firestore.pipeline.Expression transform) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that applies a provided transformation to each element in an array, + * providing the element's index to the transformation expression. + * + * ```kotlin + * // Transform 'scores' array by adding the index + * arrayTransformWithIndex("scores", "score", "i", add(variable("score"), variable("i"))) + * ``` + * + * @param arrayFieldName The name of field that contains array to transform. + * @param elementAlias The alias to use for the current element in the transform expression. + * @param indexAlias The alias to use for the current index. + * @param transform The expression used to transform the elements. + * @return A new [Expression] representing the arrayTransformWithIndex operation. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayTransformWithIndex(java.lang.String arrayFieldName, java.lang.String elementAlias, java.lang.String indexAlias, com.google.firebase.firestore.pipeline.Expression transform) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a slice of an [array] expression to its end. + * + * ```kotlin + * // Get elements from the 'items' array starting from index 2 + * arraySliceToEnd(field("items"), 2) + * ``` + * + * @param array The array expression. + * @param offset The starting index. + * @return A new [Expression] representing the arraySliceToEnd operation. + */ + +public com.google.firebase.firestore.pipeline.Expression arraySliceToEnd(com.google.firebase.firestore.pipeline.Expression array, int offset) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a slice of an [array] expression to its end. + * + * ```kotlin + * // Get elements from the 'items' array starting at an offset defined by a field + * arraySliceToEnd(field("items"), field("startIdx")) + * ``` + * + * @param array The array expression. + * @param offset The starting index. + * @return A new [Expression] representing the arraySliceToEnd operation. + */ + +public com.google.firebase.firestore.pipeline.Expression arraySliceToEnd(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression offset) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a slice of an array field to its end. + * + * ```kotlin + * // Get elements from the 'items' array starting from index 2 + * arraySliceToEnd("items", 2) + * ``` + * + * @param arrayFieldName The name of field that contains the array. + * @param offset The starting index. + * @return A new [Expression] representing the arraySliceToEnd operation. + */ + +public com.google.firebase.firestore.pipeline.Expression arraySliceToEnd(java.lang.String arrayFieldName, int offset) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a slice of an array field to its end. + * + * ```kotlin + * // Get elements from the 'items' array starting at an offset defined by a field + * arraySliceToEnd("items", field("startIdx")) + * ``` + * + * @param arrayFieldName The name of field that contains the array. + * @param offset The starting index. + * @return A new [Expression] representing the arraySliceToEnd operation. + */ + +public com.google.firebase.firestore.pipeline.Expression arraySliceToEnd(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression offset) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a slice of an [array] expression. + * + * ```kotlin + * // Get 5 elements from the 'items' array starting from index 2 + * arraySlice(field("items"), 2, 5) + * ``` + * + * @param array The array expression. + * @param offset The starting index. + * @param length The number of elements to return. + * @return A new [Expression] representing the arraySlice operation. + */ + +public com.google.firebase.firestore.pipeline.Expression arraySlice(com.google.firebase.firestore.pipeline.Expression array, int offset, int length) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a slice of an array field. + * + * ```kotlin + * // Get 5 elements from the 'items' array starting from index 2 + * arraySlice("items", 2, 5) + * ``` + * + * @param arrayFieldName The name of field that contains the array. + * @param offset The starting index. + * @param length The number of elements to return. + * @return A new [Expression] representing the arraySlice operation. + */ + +public com.google.firebase.firestore.pipeline.Expression arraySlice(java.lang.String arrayFieldName, int offset, int length) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a slice of an [array] expression. + * + * ```kotlin + * // Get elements from the 'items' array using expressions for offset and length + * arraySlice(field("items"), field("startIdx"), field("length")) + * ``` + * + * @param array The array expression. + * @param offset The starting index. + * @param length The number of elements to return. + * @return A new [Expression] representing the arraySlice operation. + */ + +public com.google.firebase.firestore.pipeline.Expression arraySlice(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression offset, com.google.firebase.firestore.pipeline.Expression length) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a slice of an array field. + * + * ```kotlin + * // Get elements from the 'items' array using expressions for offset and length + * arraySlice("items", field("startIdx"), field("length")) + * ``` + * + * @param arrayFieldName The name of field that contains the array. + * @param offset The starting index. + * @param length The number of elements to return. + * @return A new [Expression] representing the arraySlice operation. + */ + +public com.google.firebase.firestore.pipeline.Expression arraySlice(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression offset, com.google.firebase.firestore.pipeline.Expression length) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the sum of the elements in an array. + * + * ```kotlin + * // Get the sum of elements in the 'scores' array. + * arraySum(field("scores")) + * ``` + * + * @param array The array expression to sum. + * @return A new [Expression] representing the sum of the array elements. + */ + +public com.google.firebase.firestore.pipeline.Expression arraySum(com.google.firebase.firestore.pipeline.Expression array) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the sum of the elements in an array field. + * + * ```kotlin + * // Get the sum of elements in the 'scores' array. + * arraySum("scores") + * ``` + * + * @param arrayFieldName The name of the field containing the array to sum. + * @return A new [Expression] representing the sum of the array elements. + */ + +public com.google.firebase.firestore.pipeline.Expression arraySum(java.lang.String arrayFieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if the array contains a specific [element]. + * + * @param array The array expression to check. + * @param element The element to search for in the array. + * @return A new [BooleanExpression] representing the arrayContains operation. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression arrayContains(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression element) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if the array field contains a specific [element]. + * + * ```kotlin + * // Check if the 'sizes' array contains the value from the 'selectedSize' field + * arrayContains("sizes", field("selectedSize")) + * ``` + * + * @param arrayFieldName The name of field that contains array to check. + * @param element The element to search for in the array. + * @return A new [BooleanExpression] representing the arrayContains operation. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression arrayContains(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression element) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if the [array] contains a specific [element]. + * + * ```kotlin + * // Check if the 'sizes' array contains the value from the 'selectedSize' field + * arrayContains(field("sizes"), field("selectedSize")) + * + * // Check if the 'colors' array contains "red" + * arrayContains(field("colors"), "red") + * ``` + * + * @param array The array expression to check. + * @param element The element to search for in the array. + * @return A new [BooleanExpression] representing the arrayContains operation. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression arrayContains(com.google.firebase.firestore.pipeline.Expression array, java.lang.Object element) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if the array field contains a specific [element]. + * + * ```kotlin + * // Check if the 'colors' array contains "red" + * arrayContains("colors", "red") + * ``` + * + * @param arrayFieldName The name of field that contains array to check. + * @param element The element to search for in the array. + * @return A new [BooleanExpression] representing the arrayContains operation. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression arrayContains(java.lang.String arrayFieldName, java.lang.Object element) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if [array] contains all the specified [values]. + * + * ```kotlin + * // Check if the 'tags' array contains both the value in field "tag1" and the literal value "tag2" + * arrayContainsAll(field("tags"), listOf(field("tag1"), "tag2")) + * ``` + * + * @param array The array expression to check. + * @param values The elements to check for in the array. + * @return A new [BooleanExpression] representing the arrayContainsAll operation. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAll(com.google.firebase.firestore.pipeline.Expression array, java.util.List values) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if [array] contains all elements of [arrayExpression]. + * + * ```kotlin + * // Check if the 'tags' array contains both of the values from field "tag1" and the literal value "tag2" + * arrayContainsAll(field("tags"), array(field("tag1"), "tag2")) + * ``` + * + * @param array The array expression to check. + * @param arrayExpression The elements to check for in the array. + * @return A new [BooleanExpression] representing the arrayContainsAll operation. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAll(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if array field contains all the specified [values]. + * + * ```kotlin + * // Check if the 'tags' array contains both "internal" and "public" + * arrayContainsAll("tags", listOf("internal", "public")) + * ``` + * + * @param arrayFieldName The name of field that contains array to check. + * @param values The elements to check for in the array. + * @return A new [BooleanExpression] representing the arrayContainsAll operation. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAll(java.lang.String arrayFieldName, java.util.List values) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if array field contains all elements of [arrayExpression]. + * + * ```kotlin + * // Check if the 'permissions' array contains all the required permissions + * arrayContainsAll("permissions", field("requiredPermissions")) + * ``` + * + * @param arrayFieldName The name of field that contains array to check. + * @param arrayExpression The elements to check for in the array. + * @return A new [BooleanExpression] representing the arrayContainsAll operation. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAll(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if [array] contains any of the specified [values]. + * + * ```kotlin + * // Check if the 'categories' array contains either values from field "cate1" or "cate2" + * arrayContainsAny(field("categories"), listOf(field("cate1"), field("cate2"))) + * ``` + * + * @param array The array expression to check. + * @param values The elements to check for in the array. + * @return A new [BooleanExpression] representing the arrayContainsAny operation. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAny(com.google.firebase.firestore.pipeline.Expression array, java.util.List values) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if [array] contains any elements of [arrayExpression]. + * + * ```kotlin + * // Check if the 'groups' array contains either the value from the 'userGroup' field + * // or the value "guest" + * arrayContainsAny(field("groups"), array(field("userGroup"), "guest")) + * ``` + * + * @param array The array expression to check. + * @param arrayExpression The elements to check for in the array. + * @return A new [BooleanExpression] representing the arrayContainsAny operation. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAny(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if array field contains any of the specified [values]. + * + * ```kotlin + * // Check if the 'roles' array contains "admin" or "editor" + * arrayContainsAny("roles", listOf("admin", "editor")) + * ``` + * + * @param arrayFieldName The name of field that contains array to check. + * @param values The elements to check for in the array. + * @return A new [BooleanExpression] representing the arrayContainsAny operation. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAny(java.lang.String arrayFieldName, java.util.List values) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if array field contains any elements of [arrayExpression]. + * + * ```kotlin + * // Check if the 'userGroups' array contains any of the 'targetGroups' + * arrayContainsAny("userGroups", field("targetGroups")) + * ``` + * + * @param arrayFieldName The name of field that contains array to check. + * @param arrayExpression The elements to check for in the array. + * @return A new [BooleanExpression] representing the arrayContainsAny operation. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAny(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the length of an [array] expression. + * + * ```kotlin + * // Get the number of items in the 'cart' array + * arrayLength(field("cart")) + * ``` + * + * @param array The array expression to calculate the length of. + * @return A new [Expression] representing the length of the array. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayLength(com.google.firebase.firestore.pipeline.Expression array) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that calculates the length of an array field. + * + * ```kotlin + * // Get the number of items in the 'cart' array + * arrayLength("cart") + * ``` + * + * @param arrayFieldName The name of the field containing an array to calculate the length of. + * @return A new [Expression] representing the length of the array. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayLength(java.lang.String arrayFieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first element of an [array] expression. + * + * ```kotlin + * // Get the first element of the 'myArray' field. + * arrayFirst(field("myArray")) + * ``` + * + * @param array The array expression to get the first element from. + * @return A new [Expression] representing the first element. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayFirst(com.google.firebase.firestore.pipeline.Expression array) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first element of an array field. + * + * ```kotlin + * // Get the first element of the 'myArray' field. + * arrayFirst("myArray") + * ``` + * + * @param arrayFieldName The name of the field containing an array to get the first element + * from. + * @return A new [Expression] representing the first element. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayFirst(java.lang.String arrayFieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first `n` elements of an [array] expression. + * + * ```kotlin + * // Get the first 3 elements of the 'myArray' field. + * arrayFirstN(field("myArray"), 3) + * ``` + * + * @param array The array expression. + * @param n The number of elements to return. + * @return A new [Expression] representing the first `n` elements. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayFirstN(com.google.firebase.firestore.pipeline.Expression array, int n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first `n` elements of an [array] expression. + * + * ```kotlin + * // Get the first n elements of the 'myArray' field. + * arrayFirstN(field("myArray"), field("count")) + * ``` + * + * @param array The array expression. + * @param n An expression evaluating to the number of elements to return. + * @return A new [Expression] representing the first `n` elements. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayFirstN(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first `n` elements of an array field. + * + * ```kotlin + * // Get the first n elements of the 'myArray' field. + * arrayFirstN("myArray", field("count")) + * ``` + * + * @param arrayFieldName The name of the field containing an array to get the first `n` elements + * from. + * @param n An expression evaluating to the number of elements to return. + * @return A new [Expression] representing the first `n` elements. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayFirstN(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first `n` elements of an array field. + * + * ```kotlin + * // Get the first n elements of the 'myArray' field. + * arrayFirstN("myArray", 3) + * ``` + * + * @param arrayFieldName The name of the field containing an array to get the first `n` elements + * from. + * @param n The number of elements to return. + * @return A new [Expression] representing the first `n` elements. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayFirstN(java.lang.String arrayFieldName, int n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the last element of an [array] expression. + * + * ```kotlin + * // Get the last element of the 'myArray' field. + * arrayLast(field("myArray")) + * ``` + * + * @param array The array expression to get the last element from. + * @return A new [Expression] representing the last element. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayLast(com.google.firebase.firestore.pipeline.Expression array) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the last element of an array field. + * + * ```kotlin + * // Get the last element of the 'myArray' field. + * arrayLast("myArray") + * ``` + * + * @param arrayFieldName The name of the field containing an array to get the last element from. + * @return A new [Expression] representing the last element. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayLast(java.lang.String arrayFieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the last `n` elements of an [array] expression. + * + * ```kotlin + * // Get the last 3 elements of the 'myArray' field. + * arrayLastN(field("myArray"), 3) + * ``` + * + * @param array The array expression. + * @param n The number of elements to return. + * @return A new [Expression] representing the last `n` elements. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayLastN(com.google.firebase.firestore.pipeline.Expression array, int n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the last `n` elements of an [array] expression. + * + * ```kotlin + * // Get the last n elements of the 'myArray' field. + * arrayLastN(field("myArray"), field("count")) + * ``` + * + * @param array The array expression. + * @param n An expression evaluating to the number of elements to return. + * @return A new [Expression] representing the last `n` elements. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayLastN(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the last `n` elements of an array field. + * + * ```kotlin + * // Get the last n elements of the 'myArray' field. + * arrayLastN("myArray", field("count")) + * ``` + * + * @param arrayFieldName The name of the field containing an array to get the last `n` elements + * from. + * @param n An expression evaluating to the number of elements to return. + * @return A new [Expression] representing the last `n` elements. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayLastN(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the last `n` elements of an array field. + * + * ```kotlin + * // Get the last n elements of the 'myArray' field. + * arrayLastN("myArray", 3) + * ``` + * + * @param arrayFieldName The name of the field containing an array to get the last `n` elements + * from. + * @param n The number of elements to return. + * @return A new [Expression] representing the last `n` elements. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayLastN(java.lang.String arrayFieldName, int n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the minimum element of the [array]. + * + * ```kotlin + * // Get the minimum element of the 'myArray' field. + * arrayMinimum(field("myArray")) + * ``` + * + * @param array The array expression. + * @return A new [Expression] representing the minimum element. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayMinimum(com.google.firebase.firestore.pipeline.Expression array) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the minimum element of an array field. + * + * ```kotlin + * // Get the minimum element of the 'myArray' field. + * arrayMinimum("myArray") + * ``` + * + * @param arrayFieldName The name of the field containing an array to get the minimum element + * from. + * @return A new [Expression] representing the minimum element. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayMinimum(java.lang.String arrayFieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first `n` smallest elements of the [array]. + * + * Note: Returns the n smallest non-null elements in the array, in ascending order. This does + * not use a stable sort, meaning the order of equivalent elements is undefined. + * + * ```kotlin + * // Get the 3 smallest elements of the 'myArray' field. + * arrayMinimumN(field("myArray"), 3) + * ``` + * + * @param array The array expression. + * @param n The number of elements to return. + * @return A new [Expression] representing the first `n` smallest elements. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayMinimumN(com.google.firebase.firestore.pipeline.Expression array, int n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first `n` smallest elements of the [array]. + * + * Note: Returns the n smallest non-null elements in the array, in ascending order. This does + * not use a stable sort, meaning the order of equivalent elements is undefined. + * + * ```kotlin + * // Get the n smallest elements of the 'myArray' field. + * arrayMinimumN(field("myArray"), field("count")) + * ``` + * + * @param array The array expression. + * @param n An expression evaluating to the number of elements to return. + * @return A new [Expression] representing the first `n` smallest elements. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayMinimumN(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first `n` smallest elements of the [array]. + * + * Note: Returns the n smallest non-null elements in the array, in ascending order. This does + * not use a stable sort, meaning the order of equivalent elements is undefined. + * + * ```kotlin + * // Get the n smallest elements of the 'myArray' field. + * arrayMinimumN("myArray", field("count")) + * ``` + * + * @param arrayFieldName The name of the field containing an array to get the first `n` smallest + * elements from. + * @param n An expression evaluating to the number of elements to return. + * @return A new [Expression] representing the first `n` smallest elements. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayMinimumN(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first `n` smallest elements of the [array]. + * + * Note: Returns the n smallest non-null elements in the array, in ascending order. This does + * not use a stable sort, meaning the order of equivalent elements is undefined. + * + * ```kotlin + * // Get the 3 smallest elements of the 'myArray' field. + * arrayMinimumN("myArray", 3) + * ``` + * + * @param arrayFieldName The name of the field containing an array to get the first `n` smallest + * elements from. + * @param n The number of elements to return. + * @return A new [Expression] representing the first `n` smallest elements. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayMinimumN(java.lang.String arrayFieldName, int n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the maximum element of the [array]. + * + * ```kotlin + * // Get the maximum element of the 'myArray' field. + * arrayMaximum(field("myArray")) + * ``` + * + * @param array The array expression. + * @return A new [Expression] representing the maximum element. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayMaximum(com.google.firebase.firestore.pipeline.Expression array) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the maximum element of an array field. + * + * ```kotlin + * // Get the maximum element of the 'myArray' field. + * arrayMaximum("myArray") + * ``` + * + * @param arrayFieldName The name of the field containing an array to get the maximum element + * from. + * @return A new [Expression] representing the maximum element. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayMaximum(java.lang.String arrayFieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first `n` largest elements of the [array]. + * + * Note: Returns the n largest non-null elements in the array, in descending order. This does + * not use a stable sort, meaning the order of equivalent elements is undefined. + * + * ```kotlin + * // Get the 3 largest elements of the 'myArray' field. + * arrayMaximumN(field("myArray"), 3) + * ``` + * + * @param array The array expression. + * @param n The number of elements to return. + * @return A new [Expression] representing the first `n` largest elements. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayMaximumN(com.google.firebase.firestore.pipeline.Expression array, int n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first `n` largest elements of the [array]. + * + * Note: Returns the n largest non-null elements in the array, in descending order. This does + * not use a stable sort, meaning the order of equivalent elements is undefined. + * + * ```kotlin + * // Get the n largest elements of the 'myArray' field. + * arrayMaximumN(field("myArray"), field("count")) + * ``` + * + * @param array The array expression. + * @param n An expression evaluating to the number of elements to return. + * @return A new [Expression] representing the first `n` largest elements. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayMaximumN(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first `n` largest elements of the [array]. + * + * Note: Returns the n largest non-null elements in the array, in descending order. This does + * not use a stable sort, meaning the order of equivalent elements is undefined. + * + * ```kotlin + * // Get the 3 largest elements of the 'myArray' field. + * arrayMaximumN("myArray", 3) + * ``` + * + * @param arrayFieldName The name of the field containing an array to get the first `n` largest + * elements from. + * @param n The number of elements to return. + * @return A new [Expression] representing the first `n` largest elements. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayMaximumN(java.lang.String arrayFieldName, int n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first `n` largest elements of the [array]. + * + * Note: Returns the n largest non-null elements in the array, in descending order. This does + * not use a stable sort, meaning the order of equivalent elements is undefined. + * + * ```kotlin + * // Get the n largest elements of the 'myArray' field. + * arrayMaximumN("myArray", field("count")) + * ``` + * + * @param arrayFieldName The name of the field containing an array to get the first `n` largest + * elements from. + * @param n An expression evaluating to the number of elements to return. + * @return A new [Expression] representing the first `n` largest elements. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayMaximumN(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the index of the first occurrence of the specified [value] + * in the [array], or -1 if the value is not found. + * + * ```kotlin + * // Get the index of 'foo' in the 'tags' array field. + * arrayIndexOf(field("tags"), "foo") + * ``` + * + * @param array The array expression. + * @param value The value to search for. + * @return A new [Expression] representing the index of the value. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayIndexOf(com.google.firebase.firestore.pipeline.Expression array, java.lang.Object value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the index of the first occurrence of the specified [value] + * in the [array], or -1 if the value is not found. + * + * ```kotlin + * // Get the index of 'foo' in the 'tags' array field. + * arrayIndexOf(field("tags"), "foo") + * ``` + * + * @param arrayFieldName The name of the field containing an array to get the index of the value + * from. + * @param value The value to search for. + * @return A new [Expression] representing the index of the value. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayIndexOf(java.lang.String arrayFieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the index of the last occurrence of the specified [value] + * in the [array], or -1 if the value is not found. + * + * ```kotlin + * // Get the last index of 'foo' in the 'tags' array field. + * arrayLastIndexOf(field("tags"), "foo") + * ``` + * + * @param array The array expression. + * @param value The value to search for. + * @return A new [Expression] representing the last index of the value. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayLastIndexOf(com.google.firebase.firestore.pipeline.Expression array, java.lang.Object value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the index of the last occurrence of the specified [value] + * in the [array], or -1 if the value is not found. + * + * ```kotlin + * // Get the last index of 'foo' in the 'tags' array field. + * arrayLastIndexOf(field("tags"), "foo") + * ``` + * + * @param arrayFieldName The name of the field containing an array to get the last index of the + * value from. + * @param value The value to search for. + * @return A new [Expression] representing the last index of the value. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayLastIndexOf(java.lang.String arrayFieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a list of all indices where the specified [value] occurs + * in the [array]. + * + * ```kotlin + * // Get all indices of 'foo' in the 'tags' array field. + * arrayIndexOfAll(field("tags"), "foo") + * ``` + * + * @param array The array expression. + * @param value The value to search for. + * @return A new [Expression] representing the list of indices. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayIndexOfAll(com.google.firebase.firestore.pipeline.Expression array, java.lang.Object value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns a list of all indices where the specified [value] occurs + * in the [array]. + * + * ```kotlin + * // Get all indices of 'foo' in the 'tags' array field. + * arrayIndexOfAll(field("tags"), "foo") + * ``` + * + * @param arrayFieldName The name of the field containing an array to get the indices of the + * value from. + * @param value The value to search for. + * @return A new [Expression] representing the list of indices. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayIndexOfAll(java.lang.String arrayFieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that indexes into an array from the beginning or end and return the + * element. If the offset exceeds the array length, an error is returned. A negative offset, + * starts from the end. + * + * ```kotlin + * // Return the value in the tags field array at index specified by field 'favoriteTag'. + * arrayGet(field("tags"), field("favoriteTag")) + * ``` + * + * @param array An [Expression] evaluating to an array. + * @param offset An Expression evaluating to the index of the element to return. + * @return A new [Expression] representing the arrayOffset operation. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayGet(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression offset) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that indexes into an array from the beginning or end and return the + * element. If the offset exceeds the array length, an error is returned. A negative offset, + * starts from the end. + * + * ```kotlin + * // Return the value in the 'tags' field array at index `1`. + * arrayGet(field("tags"), 1) + * ``` + * + * @param array An [Expression] evaluating to an array. + * @param offset The index of the element to return. + * @return A new [Expression] representing the arrayOffset operation. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayGet(com.google.firebase.firestore.pipeline.Expression array, int offset) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that indexes into an array from the beginning or end and return the + * element. If the offset exceeds the array length, an error is returned. A negative offset, + * starts from the end. + * + * ```kotlin + * // Return the value in the tags field array at index specified by field 'favoriteTag'. + * arrayGet("tags", field("favoriteTag")) + * ``` + * + * @param arrayFieldName The name of an array field. + * @param offset An Expression evaluating to the index of the element to return. + * @return A new [Expression] representing the arrayOffset operation. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayGet(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression offset) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that indexes into an array from the beginning or end and return the + * element. If the offset exceeds the array length, an error is returned. A negative offset, + * starts from the end. + * + * ```kotlin + * // Return the value in the 'tags' field array at index `1`. + * arrayGet("tags", 1) + * ``` + * + * @param arrayFieldName The name of an array field. + * @param offset The index of the element to return. + * @return A new [Expression] representing the arrayOffset operation. + */ + +public com.google.firebase.firestore.pipeline.Expression arrayGet(java.lang.String arrayFieldName, int offset) { throw new RuntimeException("Stub!"); } + +/** + * Creates a conditional expression that evaluates to a [thenExpr] expression if a condition is + * true or an [elseExpr] expression if the condition is false. + * + * @param condition The condition to evaluate. + * @param thenExpr The expression to evaluate if the condition is true. + * @param elseExpr The expression to evaluate if the condition is false. + * @return A new [Expression] representing the conditional operation. + */ + +public com.google.firebase.firestore.pipeline.Expression conditional(com.google.firebase.firestore.pipeline.BooleanExpression condition, com.google.firebase.firestore.pipeline.Expression thenExpr, com.google.firebase.firestore.pipeline.Expression elseExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates a conditional expression that evaluates to a [thenValue] if a condition is true or an + * [elseValue] if the condition is false. + * + * ```kotlin + * // If the 'quantity' field is greater than 10, return "High", otherwise return "Low" + * conditional(field("quantity").greaterThan(10), "High", "Low") + * ``` + * + * @param condition The condition to evaluate. + * @param thenValue Value if the condition is true. + * @param elseValue Value if the condition is false. + * @return A new [Expression] representing the conditional operation. + */ + +public com.google.firebase.firestore.pipeline.Expression conditional(com.google.firebase.firestore.pipeline.BooleanExpression condition, java.lang.Object thenValue, java.lang.Object elseValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field exists. + * + * @param value An expression evaluates to the name of the field to check. + * @return A new [Expression] representing the exists check. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression exists(com.google.firebase.firestore.pipeline.Expression value) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a field exists. + * + * @param fieldName The field name to check. + * @return A new [Expression] representing the exists check. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression exists(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [catchExpr] argument if there is an error, else return + * the result of the [tryExpr] argument evaluation. + * + * ```kotlin + * // Returns the first item in the title field arrays, or returns + * // the entire title field if the array is empty or the field is another type. + * ifError(arrayGet(field("title"), 0), field("title")) + * ``` + * + * @param tryExpr The try expression. + * @param catchExpr The catch expression that will be evaluated and returned if the [tryExpr] + * produces an error. + * @return A new [Expression] representing the ifError operation. + */ + +public com.google.firebase.firestore.pipeline.Expression ifError(com.google.firebase.firestore.pipeline.Expression tryExpr, com.google.firebase.firestore.pipeline.Expression catchExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [catchExpr] argument if there is an error, else return + * the result of the [tryExpr] argument evaluation. + * + * This overload will return [BooleanExpression] when both parameters are also + * [BooleanExpression]. + * + * ```kotlin + * // Returns the result of the boolean expression, or false if it errors. + * ifError(field("is_premium"), false) + * ``` + * + * @param tryExpr The try boolean expression. + * @param catchExpr The catch boolean expression that will be evaluated and returned if the + * [tryExpr] produces an error. + * @return A new [BooleanExpression] representing the ifError operation. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression ifError(com.google.firebase.firestore.pipeline.BooleanExpression tryExpr, com.google.firebase.firestore.pipeline.BooleanExpression catchExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that checks if a given expression produces an error. + * + * ```kotlin + * // Check if the result of a calculation is an error + * isError(arrayContains(field("title"), 1)) + * ``` + * + * @param expr The expression to check. + * @return A new [BooleanExpression] representing the `isError` check. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression isError(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [catchValue] argument if there is an error, else + * return the result of the [tryExpr] argument evaluation. + * + * ```kotlin + * // Returns the first item in the title field arrays, or returns "Default Title" + * ifError(arrayGet(field("title"), 0), "Default Title") + * ``` + * + * @param tryExpr The try expression. + * @param catchValue The value that will be returned if the [tryExpr] produces an error. + * @return A new [Expression] representing the ifError operation. + */ + +public com.google.firebase.firestore.pipeline.Expression ifError(com.google.firebase.firestore.pipeline.Expression tryExpr, java.lang.Object catchValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [elseExpr] argument if [ifExpr] is absent, else return + * the result of the [ifExpr] argument evaluation. + * + * ```kotlin + * // Returns the value of the optional field 'optional_field', or returns 'default_value' + * // if the field is absent. + * ifAbsent(field("optional_field"), "default_value") + * ``` + * + * @param ifExpr The expression to check for absence. + * @param elseExpr The expression that will be evaluated and returned if [ifExpr] is absent. + * @return A new [Expression] representing the ifAbsent operation. + */ + +public com.google.firebase.firestore.pipeline.Expression ifAbsent(com.google.firebase.firestore.pipeline.Expression ifExpr, com.google.firebase.firestore.pipeline.Expression elseExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [elseValue] argument if [ifExpr] is absent, else + * return the result of the [ifExpr] argument evaluation. + * + * ```kotlin + * // Returns the value of the optional field 'optional_field', or returns 'default_value' + * // if the field is absent. + * ifAbsent(field("optional_field"), "default_value") + * ``` + * + * @param ifExpr The expression to check for absence. + * @param elseValue The value that will be returned if [ifExpr] is absent. + * @return A new [Expression] representing the ifAbsent operation. + */ + +public com.google.firebase.firestore.pipeline.Expression ifAbsent(com.google.firebase.firestore.pipeline.Expression ifExpr, java.lang.Object elseValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [elseExpr] argument if [ifFieldName] is absent, else + * return the value of the field. + * + * ```kotlin + * // Returns the value of the optional field 'optional_field', or returns the value of + * // 'default_field' if 'optional_field' is absent. + * ifAbsent("optional_field", field("default_field")) + * ``` + * + * @param ifFieldName The field to check for absence. + * @param elseExpr The expression that will be evaluated and returned if [ifFieldName] is + * absent. + * @return A new [Expression] representing the ifAbsent operation. + */ + +public com.google.firebase.firestore.pipeline.Expression ifAbsent(java.lang.String ifFieldName, com.google.firebase.firestore.pipeline.Expression elseExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [elseValue] argument if [ifFieldName] is absent, else + * return the value of the field. + * + * ```kotlin + * // Returns the value of the optional field 'optional_field', or returns 'default_value' + * // if the field is absent. + * ifAbsent("optional_field", "default_value") + * ``` + * + * @param ifFieldName The field to check for absence. + * @param elseValue The value that will be returned if [ifFieldName] is absent. + * @return A new [Expression] representing the ifAbsent operation. + */ + +public com.google.firebase.firestore.pipeline.Expression ifAbsent(java.lang.String ifFieldName, java.lang.Object elseValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [elseExpr] argument if [ifExpr] evaluates to null, + * else return the result of the [ifExpr] argument evaluation. + * + * This function provides a fallback for both absent and explicit null values. In contrast, + * [ifAbsent] only triggers for missing fields. + * + * ```kotlin + * // Returns the user's preferred name, or if that is null, returns their full name. + * ifNull(field("preferredName"), field("fullName")) + * ``` + * + * @param ifExpr The expression to check for null. + * @param elseExpr The expression that will be evaluated and returned if [ifExpr] is null. + * @return A new [Expression] representing the ifNull operation. + */ + +public com.google.firebase.firestore.pipeline.Expression ifNull(com.google.firebase.firestore.pipeline.Expression ifExpr, com.google.firebase.firestore.pipeline.Expression elseExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [elseValue] argument if [ifExpr] evaluates to null, + * else return the result of the [ifExpr] argument evaluation. + * + * This function provides a fallback for both absent and explicit null values. In contrast, + * [ifAbsent] only triggers for missing fields. + * + * ```kotlin + * // Returns the user's display name, or returns "Anonymous" if the field is null. + * ifNull(field("displayName"), "Anonymous") + * ``` + * + * @param ifExpr The expression to check for null. + * @param elseValue The value that will be returned if [ifExpr] evaluates to null. + * @return A new [Expression] representing the ifNull operation. + */ + +public com.google.firebase.firestore.pipeline.Expression ifNull(com.google.firebase.firestore.pipeline.Expression ifExpr, java.lang.Object elseValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [elseExpr] argument if [ifFieldName] field is null, + * else return the value of the field. + * + * ```kotlin + * // Returns the user's preferred name, or if that is null, returns their full name. + * ifNull("preferredName", field("fullName")) + * ``` + * + * @param ifFieldName The field to check for null. + * @param elseExpr The expression that will be evaluated and returned if [ifFieldName] is null. + * @return A new [Expression] representing the ifNull operation. + */ + +public com.google.firebase.firestore.pipeline.Expression ifNull(java.lang.String ifFieldName, com.google.firebase.firestore.pipeline.Expression elseExpr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the [elseValue] argument if [ifFieldName] field is null, + * else return the value of the field. + * + * ```kotlin + * // Returns the user's display name, or returns "Anonymous" if the field is null. + * ifNull("displayName", "Anonymous") + * ``` + * + * @param ifFieldName The field to check for null. + * @param elseValue The value that will be returned if [ifFieldName] is null. + * @return A new [Expression] representing the ifNull operation. + */ + +public com.google.firebase.firestore.pipeline.Expression ifNull(java.lang.String ifFieldName, java.lang.Object elseValue) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first non-null, non-absent argument, without + * evaluating the rest of the arguments. When all arguments are null or absent, returns the last + * argument. + * + * ```kotlin + * // Returns the value of the first non-null, non-absent field among 'preferredName', 'fullName', + * // or the last argument if all previous fields are null. + * coalesce(field("preferredName"), field("fullName"), constant("Anonymous")) + * ``` + * + * @param expression The first expression to check for null. + * @param replacement The fallback expression or value if the first one is null. + * @param others Optional additional expressions to check if previous ones are null. + * @return A new [Expression] representing the coalesce operation. + */ + +public com.google.firebase.firestore.pipeline.Expression coalesce(com.google.firebase.firestore.pipeline.Expression expression, java.lang.Object replacement, java.lang.Object... others) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the first non-null, non-absent argument, without + * evaluating the rest of the arguments. When all arguments are null or absent, returns the last + * argument. + * + * ```kotlin + * // Returns the value of the first non-null, non-absent field among 'preferredName', 'fullName', + * // or the last argument if all previous fields are null. + * coalesce("preferredName", field("fullName"), constant("Anonymous")) + * ``` + * + * @param fieldName The name of the first field to check for null. + * @param replacement The fallback expression or value if the first one is null. + * @param others Optional additional expressions to check if previous ones are null. + * @return A new [Expression] representing the coalesce operation. + */ + +public com.google.firebase.firestore.pipeline.Expression coalesce(java.lang.String fieldName, java.lang.Object replacement, java.lang.Object... others) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the collection ID from a path. + * + * ```kotlin + * // Get the collection ID from the 'path' field + * collectionId(field("path")) + * ``` + * + * @param path An expression the evaluates to a path. + * @return A new [Expression] representing the collectionId operation. + */ + +public com.google.firebase.firestore.pipeline.Expression collectionId(com.google.firebase.firestore.pipeline.Expression path) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the collection ID from a path. + * + * ```kotlin + * // Get the collection ID from a path field + * collectionId("pathField") + * ``` + * + * @param pathField The string representation of the path. + * @return A new [Expression] representing the collectionId operation. + */ + +public com.google.firebase.firestore.pipeline.Expression collectionId(java.lang.String pathField) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the document ID from a path. + * + * ```kotlin + * // Get the document ID from the 'path' field + * documentId(field("path")) + * ``` + * + * @param documentPath An expression the evaluates to document path. + * @return A new [Expression] representing the documentId operation. + */ + +public com.google.firebase.firestore.pipeline.Expression documentId(com.google.firebase.firestore.pipeline.Expression documentPath) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the document ID from a path. + * + * ```kotlin + * // Get the document ID from a path string + * documentId("projects/p/databases/d/documents/c/d") + * ``` + * + * @param documentPath The string representation of the document path. + * @return A new [Expression] representing the documentId operation. + */ + +public com.google.firebase.firestore.pipeline.Expression documentId(java.lang.String documentPath) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the document ID from a [DocumentReference]. + * + * @param docRef The [DocumentReference]. + * @return A new [Expression] representing the documentId operation. + */ + +public com.google.firebase.firestore.pipeline.Expression documentId(com.google.firebase.firestore.DocumentReference docRef) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the parent document reference of a document reference. + * + * ```kotlin + * // Get the parent document reference of a document reference. + * parent(field("__path__")) + * ``` + * + * @param documentPath An expression evaluating to a document reference. + * @return A new [Expression] representing the parent operation. + */ + +public com.google.firebase.firestore.pipeline.Expression parent(com.google.firebase.firestore.pipeline.Expression documentPath) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the parent document reference of a document reference. + * + * ```kotlin + * // Get the parent document reference of a document reference. + * parent("projects/p/databases/d/documents/c/d") + * ``` + * + * @param documentPath A string path to get the parent from. + * @return A new [Expression] representing the parent operation. + */ + +public com.google.firebase.firestore.pipeline.Expression parent(java.lang.String documentPath) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that returns the parent document reference of a document reference. + * + * ```kotlin + * // Get the parent document reference of a document reference. + * parent(myDocumentReference) + * ``` + * + * @param docRef A [DocumentReference] to get the parent from. + * @return A new [Expression] representing the parent operation. + */ + +public com.google.firebase.firestore.pipeline.Expression parent(com.google.firebase.firestore.DocumentReference docRef) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that retrieves the value of a variable bound via [Pipeline.define]. + * + * Example: + * ```kotlin + * firestore.pipeline().collection("products") + * .define( + * multiply(field("price"), 0.9).as("discountedPrice"), + * add(field("stock"), 10).as("newStock") + * ) + * .where(lessThan(variable("discountedPrice"), 100)) + * .select(field("name"), variable("newStock")); + * ``` + * + * @param name The name of the variable to retrieve. + * @return An [Expression] representing the variable's value. + */ + +public com.google.firebase.firestore.pipeline.Expression variable(java.lang.String name) { throw new RuntimeException("Stub!"); } + +/** + * Creates an expression that represents the current document being processed. + * + * Example: + * ```kotlin + * // Define the current document as a variable "doc" + * firestore.pipeline().collection("books") + * .define(currentDocument().alias("doc")) + * // Access a field from the defined document variable + * .select(variable("doc").getField("title")) + * ``` + * + * @return An [Expression] representing the current document. + */ + +public com.google.firebase.firestore.pipeline.Expression currentDocument() { throw new RuntimeException("Stub!"); } + +/** + * Evaluates to the distance in meters between the location in the specified field and the query + * location. + * + * Note: This Expression can only be used within a `Search` stage. + * + * @example + * ```kotlin + * db.pipeline().collection("restaurants").search( + * SearchStage(query = documentMatches("waffles"), sort = arrayOf(geoDistance("location", GeoPoint(37.0, -122.0)).ascending())) + * ) + * ``` + * + * @param fieldName Specifies the field in the document which contains the first GeoPoint for + * distance computation. + * @param location Compute distance to this GeoPoint. + */ + +public com.google.firebase.firestore.pipeline.Expression geoDistance(java.lang.String fieldName, com.google.firebase.firestore.GeoPoint location) { throw new RuntimeException("Stub!"); } + +/** + * Evaluates to the distance in meters between the location in the specified field and the query + * location. + * + * Note: This Expression can only be used within a `Search` stage. + * + * @example + * ```kotlin + * db.pipeline().collection("restaurants").search( + * SearchStage(query = documentMatches("waffles"), sort = arrayOf(geoDistance(field("location"), GeoPoint(37.0, -122.0)).ascending())) + * ) + * ``` + * + * @param field Specifies the field in the document which contains the first GeoPoint for + * distance computation. + * @param location Compute distance to this GeoPoint. + */ + +public com.google.firebase.firestore.pipeline.Expression geoDistance(com.google.firebase.firestore.pipeline.Field field, com.google.firebase.firestore.GeoPoint location) { throw new RuntimeException("Stub!"); } + +/** + * Perform a full-text search on all indexed search fields in the document. + * + * Note: This Expression can only be used within a `Search` stage. + * + * @example + * ```kotlin + * db.pipeline().collection("restaurants").search( + * SearchStage(query = documentMatches("waffles OR pancakes")) + * ) + * ``` + * + * @param rquery Define the search query using the search DSL. + */ + +public com.google.firebase.firestore.pipeline.BooleanExpression documentMatches(java.lang.String rquery) { throw new RuntimeException("Stub!"); } + +/** + * Evaluates to the search score that reflects the topicality of the document to all of the text + * predicates (for example: `documentMatches`) in the search query. If `SearchStage.query` is + * not set or does not contain any text predicates, then this score will always be `0`. + * + * Note: This Expression can only be used within a `Search` stage. + * @example + * ```kotlin + * db.pipeline().collection("restaurants").search( + * SearchStage(query = documentMatches("waffles"), sort = arrayOf(score().descending())) + * ) + * ``` + */ + +public com.google.firebase.firestore.pipeline.Expression score() { throw new RuntimeException("Stub!"); } +} + +} + + + +// File: Field.java +// Copyright 2025 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file 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. +// Ensure this overload exists or is correctly placed +// /** +// * Perform a full-text search on the specified field. +// * +// * Note: This Expression can only be used within a `Search` stage. +// * +// * @example +// * ```kotlin +// * db.pipeline().collection("restaurants").search( +// * SearchStage(query = matches("menu", "waffles")) +// * ) +// * ``` +// * +// * @param fieldName Perform search on this field. +// * @param rquery Define the search query using the search DSL. +// */ +// // TODO(search) this is internal until supported by the backend +// @Beta +// @JvmStatic +// internal fun matches(fieldName: String, rquery: String): BooleanExpression = +// matches(field(fieldName), rquery) +// +// /** +// * Perform a full-text search on the specified field. +// * +// * Note: This Expression can only be used within a `Search` stage. +// * +// * @example +// * ```kotlin +// * db.pipeline().collection("restaurants").search( +// * SearchStage(query = matches(field("menu"), "waffles")) +// * ) +// * ``` +// * +// * @param field Perform search on this field. +// * @param rquery Define the search query using the search DSL. +// */ +// // TODO(search) this is internal until supported by the backend +// @Beta +// @JvmStatic +// internal fun matches(field: Field, rquery: String): BooleanExpression = +// BooleanFunctionExpression("matches", notImplemented, field, constant(rquery)) +// /** +// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search +// query +// * in `bold`. +// * +// * This Expression can only be used within a `Search` stage. +// * +// * @example +// * ```kotlin +// * db.pipeline().collection("restaurants").search( +// * SearchStage(query = documentMatches("waffles"), addFields = arrayOf(snippet("menu", +// "waffles").alias("snippet"))) +// * ) +// * ``` +// * +// * @param fieldName Search the specified field for matching terms. +// * @param rquery Define the search query using the search DSL. +// */ +// @Beta +// @JvmStatic +// fun snippet(fieldName: String, rquery: String): Expression = +// FunctionExpression("snippet", notImplemented, field(fieldName), constant(rquery)) +// /** +// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search +// query +// * in `bold`. +// * +// * This Expression can only be used within a `Search` stage. +// * +// * @param fieldName Search the specified field for matching terms. +// * @param options Define how the snippet is generated. +// */ +// // TODO(search) snippet with options is internal and unimplemented until supported by the +// // backend +// @Beta +// @JvmStatic +// internal fun snippet(fieldName: String, options: SnippetOptions): Expression { +// throw NotImplementedError("Not implemented") +// } +// /** +// * Evaluates if the value in the field specified by `fieldName` is between the evaluated +// values +// * for `lowerBound` (inclusive) and `upperBound` (inclusive). +// * +// * @param fieldName Determine if this field is between two bounds. +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// */ +// // TODO(search) between is internal and unimplemented until supported by the backend +// @JvmStatic +// internal fun between( +// fieldName: String, +// lowerBound: Expression, +// upperBound: Expression +// ): BooleanExpression = +// BooleanFunctionExpression("between", notImplemented, fieldName, lowerBound, upperBound) +// /** +// * Evaluates if the value in the field specified by `fieldName` is between the values for +// * `lowerBound` (inclusive) and `upperBound` (inclusive). +// * +// * @param fieldName Determine if this field is between two bounds. +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// */ +// @JvmStatic +// internal fun between(fieldName: String, lowerBound: Any, upperBound: Any): +// BooleanExpression = +// between(fieldName, toExprOrConstant(lowerBound), toExprOrConstant(upperBound)) +// /** +// * Evaluates if the result of the specified `expression` is between the results of +// `lowerBound` +// * (inclusive) and `upperBound` (inclusive). +// * +// * @param expression Determine if the result of this expression is between two bounds. +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// */ +// @JvmStatic +// internal fun between( +// expression: Expression, +// lowerBound: Expression, +// upperBound: Expression +// ): BooleanExpression = +// BooleanFunctionExpression("between", notImplemented, expression, lowerBound, upperBound) +// /** +// * Evaluates if the result of the specified `expression` is between the `lowerBound` +// (inclusive) +// * and `upperBound` (inclusive). +// * +// * @param expression Determine if the result of this expression is between two bounds. +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// */ +// @JvmStatic +// internal fun between( +// expression: Expression, +// lowerBound: Any, +// upperBound: Any +// ): BooleanExpression = +// between(expression, toExprOrConstant(lowerBound), toExprOrConstant(upperBound)) +// // TODO(search) SnippetOptions is internal until supported by the backend +// @Beta +// internal class SnippetOptions private constructor(options: InternalOptions) : +// AbstractOptions(options) { +// /** Creates a new, empty `SnippetOptions` object. */ +// constructor(rquery: String) : this(InternalOptions.EMPTY.with("query", encodeValue(rquery))) +// +// fun withMaxSnippetWidth(max: Int): SnippetOptions { +// return with("max_snippet_width", encodeValue(max)) +// } +// +// fun withMaxSnippets(max: Int): SnippetOptions { +// return with("max_snippets", encodeValue(max)) +// } +// +// fun withSeparator(separator: String): SnippetOptions { +// return with("separator", encodeValue(separator)) +// } +// +// internal override fun self(options: InternalOptions): SnippetOptions { +// return SnippetOptions(options) +// } +// } +// /** +// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search query +// in +// * `bold`. +// * +// * Note: This Expression can only be used within a `Search` stage. +// * +// * @param rquery Define the search query using the search DTS. +// */ +// @Beta +// fun snippet(rquery: String): Expression = +// FunctionExpression( +// "snippet", +// notImplemented, +// arrayOf(this, constant(rquery)), +// SnippetOptions(rquery).options +// ) +// +// /** +// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search query +// in +// * `bold`. +// * +// * Note: This Expression can only be used within a `Search` stage. +// * +// * @param options Define how the snippet is generated. +// * +// * TODO(search) implement snippet with SnippetOptions - out of scope for first release +// */ +// @Beta +// internal fun snippet(options: SnippetOptions): Expression { +// throw NotImplementedError() +// } +// +// /** +// * Evaluates if the result of this `expression` is between the `lowerBound` (inclusive) and +// * `upperBound` (inclusive). +// * +// * @example +// * ``` +// * // Evaluate if the 'tireWidth' is between 2.2 and 2.4 +// * field('tireWidth').between(constant(2.2), constant(2.4)) +// * +// * // This is functionally equivalent to +// * and( +// * field('tireWidth').greaterThanOrEqual(constant(2.2)), +// * field('tireWidth').lessThanOrEqual(constant(2.4))) +// * ``` +// * +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// * +// * TODO(search) publish between - out of scope for first release +// */ +// internal fun between(lowerBound: Expression, upperBound: Expression): BooleanExpression = +// Companion.between(this, lowerBound, upperBound) +// +// /** +// * Evaluates if the result of this `expression` is between the `lowerBound` (inclusive) and +// * `upperBound` (inclusive). +// * +// * @example +// * ``` +// * // Evaluate if the 'tireWidth' is between 2.2 and 2.4 +// * field('tireWidth').between(2.2, 2.4) +// * +// * // This is functionally equivalent to +// * and( +// * field('tireWidth').greaterThanOrEqual(2.2), +// * field('tireWidth').lessThanOrEqual(2.4)) +// * ``` +// * +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// * +// * TODO(search) publish between - out of scope for first release +// */ +// internal fun between(lowerBound: Any, upperBound: Any): BooleanExpression = +// Companion.between(this, lowerBound, upperBound) +// +// This block runs only if fieldValue is not null. +// This value is used if getField() returns null. +// /** +// * Perform a full-text search on this field. +// * +// * Note: This Expression can only be used within a `Search` stage. +// * +// * @param rquery Define the search query using the rquery DTS. +// */ +// @Beta internal fun matches(rquery: String): BooleanExpression = matches(this, rquery) +package com.google.firebase.firestore.pipeline; + + +/** + * Represents a reference to a field in a Firestore document. + * + * [Field] references are used to access document field values in expressions and to specify fields + * for sorting, filtering, and projecting data in Firestore pipelines. + * + * You can create a [Field] instance using the static [Expression.field] method: + */ + +@SuppressWarnings({"unchecked", "deprecation", "all"}) +public final class Field extends com.google.firebase.firestore.pipeline.Selectable { + +Field() { throw new RuntimeException("Stub!"); } + +public boolean equals(java.lang.Object other) { throw new RuntimeException("Stub!"); } + +public int hashCode() { throw new RuntimeException("Stub!"); } + +/** + * Evaluates to the distance in meters between the location specified by this field and the query + * location. + * + * Note: This Expression can only be used within a `Search` stage. + * + * @param location Compute distance to this GeoPoint. + */ + +public com.google.firebase.firestore.pipeline.Expression geoDistance(com.google.firebase.firestore.GeoPoint location) { throw new RuntimeException("Stub!"); } + +public static final com.google.firebase.firestore.pipeline.Field.Companion Companion; +static { Companion = null; } +@SuppressWarnings({"unchecked", "deprecation", "all"}) +public static final class Companion { + +Companion() { throw new RuntimeException("Stub!"); } +} + +} + + + +// File: FunctionExpression.java +// Copyright 2025 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file 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. +// Ensure this overload exists or is correctly placed +// /** +// * Perform a full-text search on the specified field. +// * +// * Note: This Expression can only be used within a `Search` stage. +// * +// * @example +// * ```kotlin +// * db.pipeline().collection("restaurants").search( +// * SearchStage(query = matches("menu", "waffles")) +// * ) +// * ``` +// * +// * @param fieldName Perform search on this field. +// * @param rquery Define the search query using the search DSL. +// */ +// // TODO(search) this is internal until supported by the backend +// @Beta +// @JvmStatic +// internal fun matches(fieldName: String, rquery: String): BooleanExpression = +// matches(field(fieldName), rquery) +// +// /** +// * Perform a full-text search on the specified field. +// * +// * Note: This Expression can only be used within a `Search` stage. +// * +// * @example +// * ```kotlin +// * db.pipeline().collection("restaurants").search( +// * SearchStage(query = matches(field("menu"), "waffles")) +// * ) +// * ``` +// * +// * @param field Perform search on this field. +// * @param rquery Define the search query using the search DSL. +// */ +// // TODO(search) this is internal until supported by the backend +// @Beta +// @JvmStatic +// internal fun matches(field: Field, rquery: String): BooleanExpression = +// BooleanFunctionExpression("matches", notImplemented, field, constant(rquery)) +// /** +// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search +// query +// * in `bold`. +// * +// * This Expression can only be used within a `Search` stage. +// * +// * @example +// * ```kotlin +// * db.pipeline().collection("restaurants").search( +// * SearchStage(query = documentMatches("waffles"), addFields = arrayOf(snippet("menu", +// "waffles").alias("snippet"))) +// * ) +// * ``` +// * +// * @param fieldName Search the specified field for matching terms. +// * @param rquery Define the search query using the search DSL. +// */ +// @Beta +// @JvmStatic +// fun snippet(fieldName: String, rquery: String): Expression = +// FunctionExpression("snippet", notImplemented, field(fieldName), constant(rquery)) +// /** +// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search +// query +// * in `bold`. +// * +// * This Expression can only be used within a `Search` stage. +// * +// * @param fieldName Search the specified field for matching terms. +// * @param options Define how the snippet is generated. +// */ +// // TODO(search) snippet with options is internal and unimplemented until supported by the +// // backend +// @Beta +// @JvmStatic +// internal fun snippet(fieldName: String, options: SnippetOptions): Expression { +// throw NotImplementedError("Not implemented") +// } +// /** +// * Evaluates if the value in the field specified by `fieldName` is between the evaluated +// values +// * for `lowerBound` (inclusive) and `upperBound` (inclusive). +// * +// * @param fieldName Determine if this field is between two bounds. +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// */ +// // TODO(search) between is internal and unimplemented until supported by the backend +// @JvmStatic +// internal fun between( +// fieldName: String, +// lowerBound: Expression, +// upperBound: Expression +// ): BooleanExpression = +// BooleanFunctionExpression("between", notImplemented, fieldName, lowerBound, upperBound) +// /** +// * Evaluates if the value in the field specified by `fieldName` is between the values for +// * `lowerBound` (inclusive) and `upperBound` (inclusive). +// * +// * @param fieldName Determine if this field is between two bounds. +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// */ +// @JvmStatic +// internal fun between(fieldName: String, lowerBound: Any, upperBound: Any): +// BooleanExpression = +// between(fieldName, toExprOrConstant(lowerBound), toExprOrConstant(upperBound)) +// /** +// * Evaluates if the result of the specified `expression` is between the results of +// `lowerBound` +// * (inclusive) and `upperBound` (inclusive). +// * +// * @param expression Determine if the result of this expression is between two bounds. +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// */ +// @JvmStatic +// internal fun between( +// expression: Expression, +// lowerBound: Expression, +// upperBound: Expression +// ): BooleanExpression = +// BooleanFunctionExpression("between", notImplemented, expression, lowerBound, upperBound) +// /** +// * Evaluates if the result of the specified `expression` is between the `lowerBound` +// (inclusive) +// * and `upperBound` (inclusive). +// * +// * @param expression Determine if the result of this expression is between two bounds. +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// */ +// @JvmStatic +// internal fun between( +// expression: Expression, +// lowerBound: Any, +// upperBound: Any +// ): BooleanExpression = +// between(expression, toExprOrConstant(lowerBound), toExprOrConstant(upperBound)) +// // TODO(search) SnippetOptions is internal until supported by the backend +// @Beta +// internal class SnippetOptions private constructor(options: InternalOptions) : +// AbstractOptions(options) { +// /** Creates a new, empty `SnippetOptions` object. */ +// constructor(rquery: String) : this(InternalOptions.EMPTY.with("query", encodeValue(rquery))) +// +// fun withMaxSnippetWidth(max: Int): SnippetOptions { +// return with("max_snippet_width", encodeValue(max)) +// } +// +// fun withMaxSnippets(max: Int): SnippetOptions { +// return with("max_snippets", encodeValue(max)) +// } +// +// fun withSeparator(separator: String): SnippetOptions { +// return with("separator", encodeValue(separator)) +// } +// +// internal override fun self(options: InternalOptions): SnippetOptions { +// return SnippetOptions(options) +// } +// } +// /** +// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search query +// in +// * `bold`. +// * +// * Note: This Expression can only be used within a `Search` stage. +// * +// * @param rquery Define the search query using the search DTS. +// */ +// @Beta +// fun snippet(rquery: String): Expression = +// FunctionExpression( +// "snippet", +// notImplemented, +// arrayOf(this, constant(rquery)), +// SnippetOptions(rquery).options +// ) +// +// /** +// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search query +// in +// * `bold`. +// * +// * Note: This Expression can only be used within a `Search` stage. +// * +// * @param options Define how the snippet is generated. +// * +// * TODO(search) implement snippet with SnippetOptions - out of scope for first release +// */ +// @Beta +// internal fun snippet(options: SnippetOptions): Expression { +// throw NotImplementedError() +// } +// +// /** +// * Evaluates if the result of this `expression` is between the `lowerBound` (inclusive) and +// * `upperBound` (inclusive). +// * +// * @example +// * ``` +// * // Evaluate if the 'tireWidth' is between 2.2 and 2.4 +// * field('tireWidth').between(constant(2.2), constant(2.4)) +// * +// * // This is functionally equivalent to +// * and( +// * field('tireWidth').greaterThanOrEqual(constant(2.2)), +// * field('tireWidth').lessThanOrEqual(constant(2.4))) +// * ``` +// * +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// * +// * TODO(search) publish between - out of scope for first release +// */ +// internal fun between(lowerBound: Expression, upperBound: Expression): BooleanExpression = +// Companion.between(this, lowerBound, upperBound) +// +// /** +// * Evaluates if the result of this `expression` is between the `lowerBound` (inclusive) and +// * `upperBound` (inclusive). +// * +// * @example +// * ``` +// * // Evaluate if the 'tireWidth' is between 2.2 and 2.4 +// * field('tireWidth').between(2.2, 2.4) +// * +// * // This is functionally equivalent to +// * and( +// * field('tireWidth').greaterThanOrEqual(2.2), +// * field('tireWidth').lessThanOrEqual(2.4)) +// * ``` +// * +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// * +// * TODO(search) publish between - out of scope for first release +// */ +// internal fun between(lowerBound: Any, upperBound: Any): BooleanExpression = +// Companion.between(this, lowerBound, upperBound) +// +// This block runs only if fieldValue is not null. +// This value is used if getField() returns null. +// /** +// * Perform a full-text search on this field. +// * +// * Note: This Expression can only be used within a `Search` stage. +// * +// * @param rquery Define the search query using the rquery DTS. +// */ +// @Beta internal fun matches(rquery: String): BooleanExpression = matches(this, rquery) +package com.google.firebase.firestore.pipeline; + + +/** + * This class defines the base class for Firestore [Pipeline] functions, which can be evaluated + * within pipeline execution. + * + * Typically, you would not use this class or its children directly. Use either the functions like + * [and], [equal], or the methods on [Expression] ([Expression.equal]), [Expression.lessThan], etc) + * to construct new [FunctionExpression] instances. + */ + +@SuppressWarnings({"unchecked", "deprecation", "all"}) +public class FunctionExpression extends com.google.firebase.firestore.pipeline.Expression { + +FunctionExpression() { throw new RuntimeException("Stub!"); } + +public boolean equals(java.lang.Object other) { throw new RuntimeException("Stub!"); } + +public int hashCode() { throw new RuntimeException("Stub!"); } +} + + + +// File: Ordering.java +// Copyright 2025 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file 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. +// Ensure this overload exists or is correctly placed +// /** +// * Perform a full-text search on the specified field. +// * +// * Note: This Expression can only be used within a `Search` stage. +// * +// * @example +// * ```kotlin +// * db.pipeline().collection("restaurants").search( +// * SearchStage(query = matches("menu", "waffles")) +// * ) +// * ``` +// * +// * @param fieldName Perform search on this field. +// * @param rquery Define the search query using the search DSL. +// */ +// // TODO(search) this is internal until supported by the backend +// @Beta +// @JvmStatic +// internal fun matches(fieldName: String, rquery: String): BooleanExpression = +// matches(field(fieldName), rquery) +// +// /** +// * Perform a full-text search on the specified field. +// * +// * Note: This Expression can only be used within a `Search` stage. +// * +// * @example +// * ```kotlin +// * db.pipeline().collection("restaurants").search( +// * SearchStage(query = matches(field("menu"), "waffles")) +// * ) +// * ``` +// * +// * @param field Perform search on this field. +// * @param rquery Define the search query using the search DSL. +// */ +// // TODO(search) this is internal until supported by the backend +// @Beta +// @JvmStatic +// internal fun matches(field: Field, rquery: String): BooleanExpression = +// BooleanFunctionExpression("matches", notImplemented, field, constant(rquery)) +// /** +// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search +// query +// * in `bold`. +// * +// * This Expression can only be used within a `Search` stage. +// * +// * @example +// * ```kotlin +// * db.pipeline().collection("restaurants").search( +// * SearchStage(query = documentMatches("waffles"), addFields = arrayOf(snippet("menu", +// "waffles").alias("snippet"))) +// * ) +// * ``` +// * +// * @param fieldName Search the specified field for matching terms. +// * @param rquery Define the search query using the search DSL. +// */ +// @Beta +// @JvmStatic +// fun snippet(fieldName: String, rquery: String): Expression = +// FunctionExpression("snippet", notImplemented, field(fieldName), constant(rquery)) +// /** +// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search +// query +// * in `bold`. +// * +// * This Expression can only be used within a `Search` stage. +// * +// * @param fieldName Search the specified field for matching terms. +// * @param options Define how the snippet is generated. +// */ +// // TODO(search) snippet with options is internal and unimplemented until supported by the +// // backend +// @Beta +// @JvmStatic +// internal fun snippet(fieldName: String, options: SnippetOptions): Expression { +// throw NotImplementedError("Not implemented") +// } +// /** +// * Evaluates if the value in the field specified by `fieldName` is between the evaluated +// values +// * for `lowerBound` (inclusive) and `upperBound` (inclusive). +// * +// * @param fieldName Determine if this field is between two bounds. +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// */ +// // TODO(search) between is internal and unimplemented until supported by the backend +// @JvmStatic +// internal fun between( +// fieldName: String, +// lowerBound: Expression, +// upperBound: Expression +// ): BooleanExpression = +// BooleanFunctionExpression("between", notImplemented, fieldName, lowerBound, upperBound) +// /** +// * Evaluates if the value in the field specified by `fieldName` is between the values for +// * `lowerBound` (inclusive) and `upperBound` (inclusive). +// * +// * @param fieldName Determine if this field is between two bounds. +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// */ +// @JvmStatic +// internal fun between(fieldName: String, lowerBound: Any, upperBound: Any): +// BooleanExpression = +// between(fieldName, toExprOrConstant(lowerBound), toExprOrConstant(upperBound)) +// /** +// * Evaluates if the result of the specified `expression` is between the results of +// `lowerBound` +// * (inclusive) and `upperBound` (inclusive). +// * +// * @param expression Determine if the result of this expression is between two bounds. +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// */ +// @JvmStatic +// internal fun between( +// expression: Expression, +// lowerBound: Expression, +// upperBound: Expression +// ): BooleanExpression = +// BooleanFunctionExpression("between", notImplemented, expression, lowerBound, upperBound) +// /** +// * Evaluates if the result of the specified `expression` is between the `lowerBound` +// (inclusive) +// * and `upperBound` (inclusive). +// * +// * @param expression Determine if the result of this expression is between two bounds. +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// */ +// @JvmStatic +// internal fun between( +// expression: Expression, +// lowerBound: Any, +// upperBound: Any +// ): BooleanExpression = +// between(expression, toExprOrConstant(lowerBound), toExprOrConstant(upperBound)) +// // TODO(search) SnippetOptions is internal until supported by the backend +// @Beta +// internal class SnippetOptions private constructor(options: InternalOptions) : +// AbstractOptions(options) { +// /** Creates a new, empty `SnippetOptions` object. */ +// constructor(rquery: String) : this(InternalOptions.EMPTY.with("query", encodeValue(rquery))) +// +// fun withMaxSnippetWidth(max: Int): SnippetOptions { +// return with("max_snippet_width", encodeValue(max)) +// } +// +// fun withMaxSnippets(max: Int): SnippetOptions { +// return with("max_snippets", encodeValue(max)) +// } +// +// fun withSeparator(separator: String): SnippetOptions { +// return with("separator", encodeValue(separator)) +// } +// +// internal override fun self(options: InternalOptions): SnippetOptions { +// return SnippetOptions(options) +// } +// } +// /** +// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search query +// in +// * `bold`. +// * +// * Note: This Expression can only be used within a `Search` stage. +// * +// * @param rquery Define the search query using the search DTS. +// */ +// @Beta +// fun snippet(rquery: String): Expression = +// FunctionExpression( +// "snippet", +// notImplemented, +// arrayOf(this, constant(rquery)), +// SnippetOptions(rquery).options +// ) +// +// /** +// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search query +// in +// * `bold`. +// * +// * Note: This Expression can only be used within a `Search` stage. +// * +// * @param options Define how the snippet is generated. +// * +// * TODO(search) implement snippet with SnippetOptions - out of scope for first release +// */ +// @Beta +// internal fun snippet(options: SnippetOptions): Expression { +// throw NotImplementedError() +// } +// +// /** +// * Evaluates if the result of this `expression` is between the `lowerBound` (inclusive) and +// * `upperBound` (inclusive). +// * +// * @example +// * ``` +// * // Evaluate if the 'tireWidth' is between 2.2 and 2.4 +// * field('tireWidth').between(constant(2.2), constant(2.4)) +// * +// * // This is functionally equivalent to +// * and( +// * field('tireWidth').greaterThanOrEqual(constant(2.2)), +// * field('tireWidth').lessThanOrEqual(constant(2.4))) +// * ``` +// * +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// * +// * TODO(search) publish between - out of scope for first release +// */ +// internal fun between(lowerBound: Expression, upperBound: Expression): BooleanExpression = +// Companion.between(this, lowerBound, upperBound) +// +// /** +// * Evaluates if the result of this `expression` is between the `lowerBound` (inclusive) and +// * `upperBound` (inclusive). +// * +// * @example +// * ``` +// * // Evaluate if the 'tireWidth' is between 2.2 and 2.4 +// * field('tireWidth').between(2.2, 2.4) +// * +// * // This is functionally equivalent to +// * and( +// * field('tireWidth').greaterThanOrEqual(2.2), +// * field('tireWidth').lessThanOrEqual(2.4)) +// * ``` +// * +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// * +// * TODO(search) publish between - out of scope for first release +// */ +// internal fun between(lowerBound: Any, upperBound: Any): BooleanExpression = +// Companion.between(this, lowerBound, upperBound) +// +// This block runs only if fieldValue is not null. +// This value is used if getField() returns null. +// /** +// * Perform a full-text search on this field. +// * +// * Note: This Expression can only be used within a `Search` stage. +// * +// * @param rquery Define the search query using the rquery DTS. +// */ +// @Beta internal fun matches(rquery: String): BooleanExpression = matches(this, rquery) +package com.google.firebase.firestore.pipeline; + + +/** + * Represents an ordering criterion for sorting documents in a Firestore pipeline. + * + * You create [Ordering] instances using the [ascending] and [descending] helper methods. + */ + +@SuppressWarnings({"unchecked", "deprecation", "all"}) +public final class Ordering { + +Ordering() { throw new RuntimeException("Stub!"); } + +public boolean equals(java.lang.Object other) { throw new RuntimeException("Stub!"); } + +public int hashCode() { throw new RuntimeException("Stub!"); } + +public com.google.firebase.firestore.pipeline.Expression getExpr() { throw new RuntimeException("Stub!"); } + +public com.google.firebase.firestore.pipeline.Ordering.Direction getDir() { throw new RuntimeException("Stub!"); } + +/** + * Create an [Ordering] that sorts documents in ascending order based on value of [expr]. + * + * @param expr The order is based on the evaluation of the [Expression]. + * @return A new [Ordering] object with ascending sort by [expr]. + */ + +public static com.google.firebase.firestore.pipeline.Ordering ascending(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an [Ordering] that sorts documents in ascending order based on field. + * + * @param fieldName The name of field to sort documents. + * @return A new [Ordering] object with ascending sort by field. + */ + +public static com.google.firebase.firestore.pipeline.Ordering ascending(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Create an [Ordering] that sorts documents in descending order based on value of [expr]. + * + * @param expr The order is based on the evaluation of the [Expression]. + * @return A new [Ordering] object with descending sort by [expr]. + */ + +public static com.google.firebase.firestore.pipeline.Ordering descending(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an [Ordering] that sorts documents in descending order based on field. + * + * @param fieldName The name of field to sort documents. + * @return A new [Ordering] object with descending sort by field. + */ + +public static com.google.firebase.firestore.pipeline.Ordering descending(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +public static final com.google.firebase.firestore.pipeline.Ordering.Companion Companion; +static { Companion = null; } +@SuppressWarnings({"unchecked", "deprecation", "all"}) +public static final class Companion { + +Companion() { throw new RuntimeException("Stub!"); } + +/** + * Create an [Ordering] that sorts documents in ascending order based on value of [expr]. + * + * @param expr The order is based on the evaluation of the [Expression]. + * @return A new [Ordering] object with ascending sort by [expr]. + */ + +public com.google.firebase.firestore.pipeline.Ordering ascending(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an [Ordering] that sorts documents in ascending order based on field. + * + * @param fieldName The name of field to sort documents. + * @return A new [Ordering] object with ascending sort by field. + */ + +public com.google.firebase.firestore.pipeline.Ordering ascending(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } + +/** + * Create an [Ordering] that sorts documents in descending order based on value of [expr]. + * + * @param expr The order is based on the evaluation of the [Expression]. + * @return A new [Ordering] object with descending sort by [expr]. + */ + +public com.google.firebase.firestore.pipeline.Ordering descending(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } + +/** + * Creates an [Ordering] that sorts documents in descending order based on field. + * + * @param fieldName The name of field to sort documents. + * @return A new [Ordering] object with descending sort by field. + */ + +public com.google.firebase.firestore.pipeline.Ordering descending(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } +} + +@SuppressWarnings({"unchecked", "deprecation", "all"}) +public enum Direction { +ASCENDING, +DESCENDING; + +public error.NonExistentClass getProto() { throw new RuntimeException("Stub!"); } +} + +} + + + +// File: Selectable.java +// Copyright 2025 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file 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. +// Ensure this overload exists or is correctly placed +// /** +// * Perform a full-text search on the specified field. +// * +// * Note: This Expression can only be used within a `Search` stage. +// * +// * @example +// * ```kotlin +// * db.pipeline().collection("restaurants").search( +// * SearchStage(query = matches("menu", "waffles")) +// * ) +// * ``` +// * +// * @param fieldName Perform search on this field. +// * @param rquery Define the search query using the search DSL. +// */ +// // TODO(search) this is internal until supported by the backend +// @Beta +// @JvmStatic +// internal fun matches(fieldName: String, rquery: String): BooleanExpression = +// matches(field(fieldName), rquery) +// +// /** +// * Perform a full-text search on the specified field. +// * +// * Note: This Expression can only be used within a `Search` stage. +// * +// * @example +// * ```kotlin +// * db.pipeline().collection("restaurants").search( +// * SearchStage(query = matches(field("menu"), "waffles")) +// * ) +// * ``` +// * +// * @param field Perform search on this field. +// * @param rquery Define the search query using the search DSL. +// */ +// // TODO(search) this is internal until supported by the backend +// @Beta +// @JvmStatic +// internal fun matches(field: Field, rquery: String): BooleanExpression = +// BooleanFunctionExpression("matches", notImplemented, field, constant(rquery)) +// /** +// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search +// query +// * in `bold`. +// * +// * This Expression can only be used within a `Search` stage. +// * +// * @example +// * ```kotlin +// * db.pipeline().collection("restaurants").search( +// * SearchStage(query = documentMatches("waffles"), addFields = arrayOf(snippet("menu", +// "waffles").alias("snippet"))) +// * ) +// * ``` +// * +// * @param fieldName Search the specified field for matching terms. +// * @param rquery Define the search query using the search DSL. +// */ +// @Beta +// @JvmStatic +// fun snippet(fieldName: String, rquery: String): Expression = +// FunctionExpression("snippet", notImplemented, field(fieldName), constant(rquery)) +// /** +// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search +// query +// * in `bold`. +// * +// * This Expression can only be used within a `Search` stage. +// * +// * @param fieldName Search the specified field for matching terms. +// * @param options Define how the snippet is generated. +// */ +// // TODO(search) snippet with options is internal and unimplemented until supported by the +// // backend +// @Beta +// @JvmStatic +// internal fun snippet(fieldName: String, options: SnippetOptions): Expression { +// throw NotImplementedError("Not implemented") +// } +// /** +// * Evaluates if the value in the field specified by `fieldName` is between the evaluated +// values +// * for `lowerBound` (inclusive) and `upperBound` (inclusive). +// * +// * @param fieldName Determine if this field is between two bounds. +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// */ +// // TODO(search) between is internal and unimplemented until supported by the backend +// @JvmStatic +// internal fun between( +// fieldName: String, +// lowerBound: Expression, +// upperBound: Expression +// ): BooleanExpression = +// BooleanFunctionExpression("between", notImplemented, fieldName, lowerBound, upperBound) +// /** +// * Evaluates if the value in the field specified by `fieldName` is between the values for +// * `lowerBound` (inclusive) and `upperBound` (inclusive). +// * +// * @param fieldName Determine if this field is between two bounds. +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// */ +// @JvmStatic +// internal fun between(fieldName: String, lowerBound: Any, upperBound: Any): +// BooleanExpression = +// between(fieldName, toExprOrConstant(lowerBound), toExprOrConstant(upperBound)) +// /** +// * Evaluates if the result of the specified `expression` is between the results of +// `lowerBound` +// * (inclusive) and `upperBound` (inclusive). +// * +// * @param expression Determine if the result of this expression is between two bounds. +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// */ +// @JvmStatic +// internal fun between( +// expression: Expression, +// lowerBound: Expression, +// upperBound: Expression +// ): BooleanExpression = +// BooleanFunctionExpression("between", notImplemented, expression, lowerBound, upperBound) +// /** +// * Evaluates if the result of the specified `expression` is between the `lowerBound` +// (inclusive) +// * and `upperBound` (inclusive). +// * +// * @param expression Determine if the result of this expression is between two bounds. +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// */ +// @JvmStatic +// internal fun between( +// expression: Expression, +// lowerBound: Any, +// upperBound: Any +// ): BooleanExpression = +// between(expression, toExprOrConstant(lowerBound), toExprOrConstant(upperBound)) +// // TODO(search) SnippetOptions is internal until supported by the backend +// @Beta +// internal class SnippetOptions private constructor(options: InternalOptions) : +// AbstractOptions(options) { +// /** Creates a new, empty `SnippetOptions` object. */ +// constructor(rquery: String) : this(InternalOptions.EMPTY.with("query", encodeValue(rquery))) +// +// fun withMaxSnippetWidth(max: Int): SnippetOptions { +// return with("max_snippet_width", encodeValue(max)) +// } +// +// fun withMaxSnippets(max: Int): SnippetOptions { +// return with("max_snippets", encodeValue(max)) +// } +// +// fun withSeparator(separator: String): SnippetOptions { +// return with("separator", encodeValue(separator)) +// } +// +// internal override fun self(options: InternalOptions): SnippetOptions { +// return SnippetOptions(options) +// } +// } +// /** +// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search query +// in +// * `bold`. +// * +// * Note: This Expression can only be used within a `Search` stage. +// * +// * @param rquery Define the search query using the search DTS. +// */ +// @Beta +// fun snippet(rquery: String): Expression = +// FunctionExpression( +// "snippet", +// notImplemented, +// arrayOf(this, constant(rquery)), +// SnippetOptions(rquery).options +// ) +// +// /** +// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search query +// in +// * `bold`. +// * +// * Note: This Expression can only be used within a `Search` stage. +// * +// * @param options Define how the snippet is generated. +// * +// * TODO(search) implement snippet with SnippetOptions - out of scope for first release +// */ +// @Beta +// internal fun snippet(options: SnippetOptions): Expression { +// throw NotImplementedError() +// } +// +// /** +// * Evaluates if the result of this `expression` is between the `lowerBound` (inclusive) and +// * `upperBound` (inclusive). +// * +// * @example +// * ``` +// * // Evaluate if the 'tireWidth' is between 2.2 and 2.4 +// * field('tireWidth').between(constant(2.2), constant(2.4)) +// * +// * // This is functionally equivalent to +// * and( +// * field('tireWidth').greaterThanOrEqual(constant(2.2)), +// * field('tireWidth').lessThanOrEqual(constant(2.4))) +// * ``` +// * +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// * +// * TODO(search) publish between - out of scope for first release +// */ +// internal fun between(lowerBound: Expression, upperBound: Expression): BooleanExpression = +// Companion.between(this, lowerBound, upperBound) +// +// /** +// * Evaluates if the result of this `expression` is between the `lowerBound` (inclusive) and +// * `upperBound` (inclusive). +// * +// * @example +// * ``` +// * // Evaluate if the 'tireWidth' is between 2.2 and 2.4 +// * field('tireWidth').between(2.2, 2.4) +// * +// * // This is functionally equivalent to +// * and( +// * field('tireWidth').greaterThanOrEqual(2.2), +// * field('tireWidth').lessThanOrEqual(2.4)) +// * ``` +// * +// * @param lowerBound Lower bound (inclusive). +// * @param upperBound Upper bound (inclusive). +// * +// * TODO(search) publish between - out of scope for first release +// */ +// internal fun between(lowerBound: Any, upperBound: Any): BooleanExpression = +// Companion.between(this, lowerBound, upperBound) +// +// This block runs only if fieldValue is not null. +// This value is used if getField() returns null. +// /** +// * Perform a full-text search on this field. +// * +// * Note: This Expression can only be used within a `Search` stage. +// * +// * @param rquery Define the search query using the rquery DTS. +// */ +// @Beta internal fun matches(rquery: String): BooleanExpression = matches(this, rquery) +package com.google.firebase.firestore.pipeline; + + +/** Expressions that have an alias are [Selectable] */ + +@SuppressWarnings({"unchecked", "deprecation", "all"}) +public abstract class Selectable extends com.google.firebase.firestore.pipeline.Expression { + +/** Expressions that have an alias are [Selectable] */ + +public Selectable() { throw new RuntimeException("Stub!"); } +} + + + diff --git a/firebase-firestore/src/main/assets/pipeline.docs.txt b/firebase-firestore/src/main/assets/pipeline.docs.txt new file mode 100644 index 00000000000..3470a3feaad --- /dev/null +++ b/firebase-firestore/src/main/assets/pipeline.docs.txt @@ -0,0 +1,1294 @@ +// File: Pipeline.java +// Copyright 2025 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file 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. +// Validate document path by converting to DocumentReference +package com.google.firebase.firestore; + + +/** + * A `Pipeline` is composed of a sequence of stages. Each stage processes the output from the + * previous one, and the final stage's output is the result of the pipeline's execution. + * + * **Example usage:** + * + * ```kotlin + * val pipeline = firestore.pipeline() + * .collection("books") + * .where(field("rating").greaterThan(4.5)) + * .sort(field("rating").descending()) + * .limit(2) + * ``` + * + * **Note on Execution:** The stages are conceptual. The Firestore backend may optimize execution + * (e.g., reordering or merging stages) as long as the final result remains the same. + * + * **Important Limitations:** + * - Pipelines operate on a **request/response basis only**. + * - They do **not** utilize or update the local SDK cache. + * - They do **not** support realtime snapshot listeners. + */ + +@SuppressWarnings({"unchecked", "deprecation", "all"}) +public final class Pipeline { + +Pipeline() { throw new RuntimeException("Stub!"); } + +/** + * Executes this pipeline and returns the results as a [Task] of [Snapshot]. + * + * @return A [Task] that will be resolved with the results of the pipeline. + */ + +public com.google.android.gms.tasks.Task execute() { throw new RuntimeException("Stub!"); } + +/** + * Executes this pipeline and returns the results as a [Task] of [Snapshot]. + * + * @param options The [ExecuteOptions] to use to instruct Firestore backend execution. + * @return A [Task] that will be resolved with the results of the pipeline. + */ + +public com.google.android.gms.tasks.Task execute(com.google.firebase.firestore.Pipeline.ExecuteOptions options) { throw new RuntimeException("Stub!"); } + +/** + * Adds a raw stage to the pipeline by specifying the stage name as an argument. This does not + * offer any type safety on the stage params and requires the caller to know the order (and + * optionally names) of parameters accepted by the stage. + * + * This method provides a way to call stages that are supported by the Firestore backend but that + * are not implemented in the SDK version being used. + * + * @param rawStage A [RawStage] object that specifies stage name and parameters. + * @return A new [Pipeline] object with this stage appended to the stage list. + */ + +public com.google.firebase.firestore.Pipeline rawStage(com.google.firebase.firestore.pipeline.RawStage rawStage) { throw new RuntimeException("Stub!"); } + +/** + * Adds new fields to outputs from previous stages. + * + * This stage allows you to compute values on-the-fly based on existing data from previous stages + * or constants. You can use this to create new fields or overwrite existing ones. + * + * The added fields are defined using [Selectable]s, which can be: + * + * - [Field]: References an existing document field. + * - [AliasedExpression]: Represents the result of a expression with an assigned alias name using + * [Expr.alias] + * + * Example: + * ```kotlin + * firestore.pipeline().collection("books") + * .addFields( + * field("rating").as("bookRating"), // Rename 'rating' to 'bookRating' + * add(5, field("quantity")).as("totalCost") // Calculate 'totalCost' + * ) + * ``` + * + * @param field The first field to add to the documents, specified as a [Selectable]. + * @param additionalFields The fields to add to the documents, specified as [Selectable]s. + * @return A new [Pipeline] object with this stage appended to the stage list. + */ + +public com.google.firebase.firestore.Pipeline addFields(com.google.firebase.firestore.pipeline.Selectable field, com.google.firebase.firestore.pipeline.Selectable... additionalFields) { throw new RuntimeException("Stub!"); } + +/** + * Remove fields from outputs of previous stages. + * + * Example: + * ```kotlin + * firestore.pipeline().collection("books") + * .removeFields( + * field("rating"), field("cost") + * ) + * ``` + * + * @param field The first [Field] to remove. + * @param additionalFields Optional additional [Field]s to remove. + * @return A new [Pipeline] object with this stage appended to the stage list. + */ + +public com.google.firebase.firestore.Pipeline removeFields(com.google.firebase.firestore.pipeline.Field field, com.google.firebase.firestore.pipeline.Field... additionalFields) { throw new RuntimeException("Stub!"); } + +/** + * Remove fields from outputs of previous stages. + * + * Example: + * ```kotlin + * firestore.pipeline().collection("books") + * .removeFields( + * "rating", "cost" + * ) + * ``` + * + * @param field The first [String] name of field to remove. + * @param additionalFields Optional additional [String] name of fields to remove. + * @return A new [Pipeline] object with this stage appended to the stage list. + */ + +public com.google.firebase.firestore.Pipeline removeFields(java.lang.String field, java.lang.String... additionalFields) { throw new RuntimeException("Stub!"); } + +/** + * Selects or creates a set of fields from the outputs of previous stages. + * + * The selected fields are defined using [Selectable] expressions or strings, which can be: + * + * - [String]: Name of an existing field + * - [Field]: Reference to an existing field. + * - [AliasedExpression]: Represents the result of a expression with an assigned alias name using + * [Expr.alias] + * + * If no selections are provided, the output of this stage is empty. Use [Pipeline.addFields] + * instead if only additions are desired. + * + * Example: + * ```kotlin + * firestore.pipeline().collection("books") + * .select( + * field("name"), + * field("address").toUppercase().as("upperAddress"), + * ) + * ``` + * + * @param selection The first field to include in the output documents, specified as a + * [Selectable] expression. + * @param additionalSelections Optional additional fields to include in the output documents, + * specified as [Selectable] expressions or string values representing field names. + * @return A new [Pipeline] object with this stage appended to the stage list. + */ + +public com.google.firebase.firestore.Pipeline select(com.google.firebase.firestore.pipeline.Selectable selection, java.lang.Object... additionalSelections) { throw new RuntimeException("Stub!"); } + +/** + * Selects or creates a set of fields from the outputs of previous stages. + * + * The selected fields are defined using [Selectable] expressions, which can be: + * + * - [String]: Name of an existing field + * - [Field]: Reference to an existing field. + * - [AliasedExpression]: Represents the result of a expression with an assigned alias name using + * [Expr.alias] + * + * If no selections are provided, the output of this stage is empty. Use [Pipeline.addFields] + * instead if only additions are desired. + * + * Example: + * ```kotlin + * firestore.collection("books") + * .select("name", "address") + * + * // The above is a shorthand of this: + * firestore.pipeline().collection("books") + * .select(field("name"), field("address")) + * ``` + * + * @param fieldName The first field to include in the output documents, specified as a string + * value representing a field names. + * @param additionalSelections Optional additional fields to include in the output documents, + * specified as [Selectable] expressions or string values representing field names. + * @return A new [Pipeline] object with this stage appended to the stage list. + */ + +public com.google.firebase.firestore.Pipeline select(java.lang.String fieldName, java.lang.Object... additionalSelections) { throw new RuntimeException("Stub!"); } + +/** + * Sorts the documents from previous stages based on one or more [Ordering] criteria. + * + * This stage allows you to order the results of your pipeline. You can specify multiple + * [Ordering] instances to sort by multiple fields in ascending or descending order. If documents + * have the same value for a field used for sorting, the next specified ordering will be used. If + * all orderings result in equal comparison, the documents are considered equal and the order is + * unspecified. + * + * Example: + * ```kotlin + * // Sort books by rating in descending order, and then by title in ascending order for books with the same rating + * firestore.pipeline().collection("books") + * .sort( + * Ordering.of("rating").descending(), + * Ordering.of("title") // Ascending order is the default + * ) + * ``` + * + * @param order The first [Ordering] instance specifying the sorting criteria. + * @param additionalOrders Optional additional [Ordering] instances specifying the sorting + * criteria. + * @return A new [Pipeline] object with this stage appended to the stage list. + */ + +public com.google.firebase.firestore.Pipeline sort(com.google.firebase.firestore.pipeline.Ordering order, com.google.firebase.firestore.pipeline.Ordering... additionalOrders) { throw new RuntimeException("Stub!"); } + +/** + * Filters the documents from previous stages to only include those matching the specified + * [BooleanExpression]. + * + * This stage allows you to apply conditions to the data, similar to a "WHERE" clause in SQL. + * + * You can filter documents based on their field values, using implementations of + * [BooleanExpression], typically including but not limited to: + * + * - field comparators: [Expr.equal], [Expr.lessThan], [Expr.greaterThan], etc. + * - logical operators: [Expr.and], [Expr.or], [Expr.not], etc. + * - advanced functions: [Expr.regexMatch], [Expr.arrayContains], etc. + * + * Example: + * ```kotlin + * firestore.pipeline().collection("books") + * .where( + * and( + * gt("rating", 4.0), // Filter for ratings greater than 4.0 + * field("genre").equal("Science Fiction") // Equivalent to equal("genre", "Science Fiction") + * ) + * ) + * ``` + * + * @param condition The [BooleanExpression] to apply. + * @return A new [Pipeline] object with this stage appended to the stage list. + */ + +public com.google.firebase.firestore.Pipeline where(com.google.firebase.firestore.pipeline.BooleanExpression condition) { throw new RuntimeException("Stub!"); } + +/** + * Skips the first `offset` number of documents from the results of previous stages. + * + * This stage is useful for implementing pagination in your pipelines, allowing you to retrieve + * results in chunks. It is typically used in conjunction with [limit] to control the size of each + * page. + * + * Example: + * ```kotlin + * // Retrieve the second page of 20 results + * firestore.pipeline().collection("books") + * .sort(field("published").descending()) + * .offset(20) // Skip the first 20 results + * .limit(20) // Take the next 20 results + * ``` + * + * @param offset The number of documents to skip. + * @return A new [Pipeline] object with this stage appended to the stage list. + */ + +public com.google.firebase.firestore.Pipeline offset(int offset) { throw new RuntimeException("Stub!"); } + +/** + * Limits the maximum number of documents returned by previous stages to `limit`. + * + * This stage is particularly useful when you want to retrieve a controlled subset of data from a + * potentially large result set. It's often used for: + * + * - **Pagination:** In combination with [offset] to retrieve specific pages of results. + * - **Limiting Data Retrieval:** To prevent excessive data transfer and improve performance, + * especially when dealing with large collections. + * + * Example: + * ```kotlin + * // Limit the results to the top 10 highest-rated books + * firestore.pipeline().collection("books") + * .sort(field("rating").descending()) + * .limit(10) + * ``` + * + * @param limit The maximum number of documents to return. + * @return A new [Pipeline] object with this stage appended to the stage list. + */ + +public com.google.firebase.firestore.Pipeline limit(int limit) { throw new RuntimeException("Stub!"); } + +/** + * Returns a set of distinct values from the inputs to this stage. + * + * This stage runs through the results from previous stages to include only results with unique + * combinations of [Expr] values [Field], [FunctionExpression], etc). + * + * The parameters to this stage are defined using [Selectable] expressions or strings: + * + * - [String]: Name of an existing field + * - [Field]: References an existing document field. + * - [AliasedExpression]: Represents the result of a function with an assigned alias name using + * [Expr.alias] + * + * Example: + * ```kotlin + * // Get a list of unique author names in uppercase and genre combinations. + * firestore.pipeline().collection("books") + * .distinct(toUppercase(field("author")).as("authorName"), field("genre")) + * .select("authorName") + * ``` + * + * @param group The [Selectable] expression to consider when determining distinct value + * combinations. + * @param additionalGroups The [Selectable] expressions to consider when determining distinct + * value combinations or [String]s representing field names. + * @return A new [Pipeline] object with this stage appended to the stage list. + */ + +public com.google.firebase.firestore.Pipeline distinct(com.google.firebase.firestore.pipeline.Selectable group, java.lang.Object... additionalGroups) { throw new RuntimeException("Stub!"); } + +/** + * Returns a set of distinct values from the inputs to this stage. + * + * This stage runs through the results from previous stages to include only results with unique + * combinations of [Expr] values ([Field], [FunctionExpression], etc). + * + * The parameters to this stage are defined using [Selectable] expressions or strings: + * + * - [String]: Name of an existing field + * - [Field]: References an existing document field. + * - [AliasedExpression]: Represents the result of a function with an assigned alias name using + * [Expr.alias] + * + * Example: + * ```kotlin + * // Get a list of unique genres. + * firestore.pipeline().collection("books") + * .distinct("genre") + * ``` + * + * @param groupField The [String] representing field name. + * @param additionalGroups The [Selectable] expressions to consider when determining distinct + * value combinations or [String]s representing field names. + * @return A new [Pipeline] object with this stage appended to the stage list. + */ + +public com.google.firebase.firestore.Pipeline distinct(java.lang.String groupField, java.lang.Object... additionalGroups) { throw new RuntimeException("Stub!"); } + +/** + * Performs aggregation operations on the documents from previous stages. + * + * This stage allows you to calculate aggregate values over a set of documents. You define the + * aggregations to perform using [AliasedAggregate] expressions which are typically results of + * calling [AggregateFunction.alias] on [AggregateFunction] instances. + * + * Example: + * ```kotlin + * // Calculate the average rating and the total number of books + * firestore.pipeline().collection("books") + * .aggregate( + * field("rating").average().as("averageRating"), + * countAll().as("totalBooks") + * ) + * ``` + * + * @param accumulator The first [AliasedAggregate] expression, wrapping an [AggregateFunction] + * with an alias for the accumulated results. + * @param additionalAccumulators The [AliasedAggregate] expressions, each wrapping an + * [AggregateFunction] with an alias for the accumulated results. + * @return A new [Pipeline] object with this stage appended to the stage list. + */ + +public com.google.firebase.firestore.Pipeline aggregate(com.google.firebase.firestore.pipeline.AliasedAggregate accumulator, com.google.firebase.firestore.pipeline.AliasedAggregate... additionalAccumulators) { throw new RuntimeException("Stub!"); } + +/** + * Performs optionally grouped aggregation operations on the documents from previous stages. + * + * This stage allows you to calculate aggregate values over a set of documents, optionally grouped + * by one or more fields or functions. You can specify: + * + * - **Grouping Fields or Expressions:** One or more fields or functions to group the documents + * by. For each distinct combination of values in these fields, a separate group is created. If no + * grouping fields are provided, a single group containing all documents is used. Not specifying + * groups is the same as putting the entire inputs into one group. + * + * - **AggregateFunctions:** One or more accumulation operations to perform within each group. + * These are defined using [AliasedAggregate] expressions, which are typically created by calling + * [AggregateFunction.alias] on [AggregateFunction] instances. Each aggregation calculates a value + * (e.g., sum, average, count) based on the documents within its group. + * + * Example: + * ```kotlin + * // Calculate the average rating for each genre. + * firestore.pipeline().collection("books") + * .aggregate( + * Aggregate + * .withAccumulators(average("rating").as("avg_rating")) + * .withGroups("genre")) + * ``` + * + * @param aggregateStage An [AggregateStage] object that specifies the grouping fields (if any) + * and the aggregation operations to perform. + * @return A new [Pipeline] object with this stage appended to the stage list. + */ + +public com.google.firebase.firestore.Pipeline aggregate(com.google.firebase.firestore.pipeline.AggregateStage aggregateStage) { throw new RuntimeException("Stub!"); } + +/** + * Performs optionally grouped aggregation operations on the documents from previous stages. + * + * This stage allows you to calculate aggregate values over a set of documents, optionally grouped + * by one or more fields or functions. You can specify: + * + * - **Grouping Fields or Expressions:** One or more fields or functions to group the documents + * by. For each distinct combination of values in these fields, a separate group is created. If no + * grouping fields are provided, a single group containing all documents is used. Not specifying + * groups is the same as putting the entire inputs into one group. + * + * - **AggregateFunctions:** One or more accumulation operations to perform within each group. + * These are defined using [AliasedAggregate] expressions, which are typically created by calling + * [AggregateFunction.alias] on [AggregateFunction] instances. Each aggregation calculates a value + * (e.g., sum, average, count) based on the documents within its group. + * + * @param aggregateStage An [AggregateStage] object that specifies the grouping fields (if any) + * and the aggregation operations to perform. + * @param options The [AggregateOptions] to use when performing the aggregation. + * @return A new [Pipeline] object with this stage appended to the stage list. + */ + +public com.google.firebase.firestore.Pipeline aggregate(com.google.firebase.firestore.pipeline.AggregateStage aggregateStage, com.google.firebase.firestore.pipeline.AggregateOptions options) { throw new RuntimeException("Stub!"); } + +/** + * Performs a vector similarity search, ordering the result set by most similar to least similar, + * and returning the full set in the order of similarity. + * + * @param vectorField A [String] specifying the vector field to search on. + * @param vectorValue The [DoubleArray] that is used to measure the distance from [vectorField] + * values in the documents. + * @param distanceMeasure specifies what type of distance is calculated when performing the + * search. + * @return A new [Pipeline] object with this stage appended to the stage list. + */ + +public com.google.firebase.firestore.Pipeline findNearest(java.lang.String vectorField, double[] vectorValue, com.google.firebase.firestore.pipeline.FindNearestStage.DistanceMeasure distanceMeasure) { throw new RuntimeException("Stub!"); } + +/** + * Performs a vector similarity search, ordering the result set by most similar to least similar, + * and returning the full set in the order of similarity. + * + * @param vectorField A [Field] that contains vector to search on. + * @param vectorValue The [DoubleArray] that is used to measure the distance from [vectorField] + * values in the documents. + * @param distanceMeasure specifies what type of distance is calculated. when performing the + * search. + * @return A new [Pipeline] object with this stage appended to the stage list. + */ + +public com.google.firebase.firestore.Pipeline findNearest(com.google.firebase.firestore.pipeline.Field vectorField, double[] vectorValue, com.google.firebase.firestore.pipeline.FindNearestStage.DistanceMeasure distanceMeasure) { throw new RuntimeException("Stub!"); } + +/** + * Performs a vector similarity search, ordering the result set by most similar to least similar, + * and returning the first N documents (specified by [FindNearestOptions.withLimit]) in the result + * set. + * + * Example: + * ```kotlin + * // Find books with similar "topicVectors" to the given targetVector + * firestore.pipeline().collection("books") + * .findNearest("topicVectors", targetVector, FindNearest.DistanceMeasure.COSINE, + * FindNearestOptions() + * .withLimit(10) + * .withDistanceField("distance")) + * ``` + * + * @param vectorField A field name that contains vector to search on. + * @param vectorValue The [Expression] that should evaluate to a vector used to measure the + * distance from [vectorField] values in the documents. + * @param distanceMeasure specifies what type of distance is calculated when performing the + * search. + * @param options The [FindNearestOptions] to use when performing the search. + * @return A new [Pipeline] object with this stage appended to the stage list. + */ + +public com.google.firebase.firestore.Pipeline findNearest(java.lang.String vectorField, com.google.firebase.firestore.pipeline.Expression vectorValue, com.google.firebase.firestore.pipeline.FindNearestStage.DistanceMeasure distanceMeasure, com.google.firebase.firestore.pipeline.FindNearestOptions options) { throw new RuntimeException("Stub!"); } + +/** + * Fully overwrites all fields in a document with those coming from a nested map. + * + * This stage allows you to emit a map value as a document. Each key of the map becomes a field on + * the document that contains the corresponding value. + * + * Example: + * ```kotlin + * // Input. + * // { + * // "name": "John Doe Jr.", + * // "parents": { + * // "father": "John Doe Sr.", + * // "mother": "Jane Doe" + * // } + * + * // Emit parents as document. + * firestore.pipeline().collection("people").replaceWith("parents") + * + * // Output + * // { + * // "father": "John Doe Sr.", + * // "mother": "Jane Doe" + * // } + * ``` + * + * @param field The [String] specifying the field name containing the nested map. + * @return A new [Pipeline] object with this stage appended to the stage list. + */ + +public com.google.firebase.firestore.Pipeline replaceWith(java.lang.String field) { throw new RuntimeException("Stub!"); } + +/** + * Fully overwrites all fields in a document with those coming from a nested map. + * + * This stage allows you to emit a map value as a document. Each key of the map becomes a field on + * the document that contains the corresponding value. + * + * Example: + * ```kotlin + * // Input. + * // { + * // "name": "John Doe Jr.", + * // "parents": { + * // "father": "John Doe Sr.", + * // "mother": "Jane Doe" + * // } + * + * // Emit parents as document. + * firestore.pipeline().collection("people").replaceWith(field("parents")) + * + * // Output + * // { + * // "father": "John Doe Sr.", + * // "mother": "Jane Doe" + * // } + * ``` + * + * @param mapValue The [Expression] or [Field] containing the nested map. + * @return A new [Pipeline] object with this stage appended to the stage list. + */ + +public com.google.firebase.firestore.Pipeline replaceWith(com.google.firebase.firestore.pipeline.Expression mapValue) { throw new RuntimeException("Stub!"); } + +/** + * Performs a pseudo-random sampling of the input documents. + * + * The [documents] parameter represents the target number of documents to produce and must be a + * non-negative integer value. If the previous stage produces less than size documents, the entire + * previous results are returned. If the previous stage produces more than size, this outputs a + * sample of exactly size entries where any sample is equally likely. + * + * Example: + * ```kotlin + * // Sample 10 books, if available. + * firestore.pipeline().collection("books") + * .sample(10) + * ``` + * + * @param documents The number of documents to emit. + * @return A new [Pipeline] object with this stage appended to the stage list. + */ + +public com.google.firebase.firestore.Pipeline sample(int documents) { throw new RuntimeException("Stub!"); } + +/** + * Performs a pseudo-random sampling of the input documents. + * + * Examples: + * ```kotlin + * // Sample 10 books, if available. + * firestore.pipeline().collection("books") + * .sample(Sample.withDocLimit(10)) + * + * // Sample 50% of books. + * firestore.pipeline().collection("books") + * .sample(Sample.withPercentage(0.5)) + * ``` + * + * @param sample An [SampleStage] object that specifies how sampling is performed. + * @return A new [Pipeline] object with this stage appended to the stage list. + */ + +public com.google.firebase.firestore.Pipeline sample(com.google.firebase.firestore.pipeline.SampleStage sample) { throw new RuntimeException("Stub!"); } + +/** + * Performs union of all documents from two pipelines, including duplicates. + * + * This stage will pass through documents from previous stage, and also pass through documents + * from previous stage of the `other` Pipeline given in parameter. The order of documents emitted + * from this stage is undefined. + * + * Example: + * ```kotlin + * // Emit documents from books collection and magazines collection. + * firestore.pipeline().collection("books") + * .union(firestore.pipeline().collection("magazines")) + * ``` + * + * @param other The other [Pipeline] that is part of union. + * @return A new [Pipeline] object with this stage appended to the stage list. + */ + +public com.google.firebase.firestore.Pipeline union(com.google.firebase.firestore.Pipeline other) { throw new RuntimeException("Stub!"); } + +/** + * Takes a specified array from the input documents and outputs a document for each element with + * the element stored in a field with name specified by the alias. + * + * For each document emitted by the prior stage, this stage will emit zero or more augmented + * documents. The input array found in the previous stage document field specified by the + * [arrayField] parameter, will for each element of the input array produce an augmented document. + * The element of the input array will be stored in a field with name specified by [alias] + * parameter on the augmented document. + * + * Example: + * ```kotlin + * // Input: + * // { "title": "The Hitchhiker's Guide to the Galaxy", "tags": [ "comedy", "space", "adventure" ], ... } + * + * // Emit a book document for each tag of the book. + * firestore.pipeline().collection("books") + * .unnest("tags", "tag") + * + * // Output: + * // { "title": "The Hitchhiker's Guide to the Galaxy", "tag": "comedy", ... } + * // { "title": "The Hitchhiker's Guide to the Galaxy", "tag": "space", ... } + * // { "title": "The Hitchhiker's Guide to the Galaxy", "tag": "adventure", ... } + * ``` + * + * @param arrayField The name of the field containing the array. + * @param alias The name of field to store emitted element of array. + * @return A new [Pipeline] object with this stage appended to the stage list. + */ + +public com.google.firebase.firestore.Pipeline unnest(java.lang.String arrayField, java.lang.String alias) { throw new RuntimeException("Stub!"); } + +/** + * Takes a specified array from the input documents and outputs a document for each element with + * the element stored in a field with name specified by the alias. + * + * For each document emitted by the prior stage, this stage will emit zero or more augmented + * documents. The input array is found in parameter [arrayWithAlias], which can be an [Expr] with + * an alias specified via [Expr.alias], or a [Field] that can also have alias specified. For each + * element of the input array, an augmented document will be produced. The element of input array + * will be stored in a field with name specified by the alias of the [arrayWithAlias] parameter. + * If the [arrayWithAlias] is a [Field] with no alias, then the original array field will be + * replaced with the individual element. + * + * @param arrayWithAlias The input array with field alias to store output element of array. + * @return A new [Pipeline] object with this stage appended to the stage list. + */ + +public com.google.firebase.firestore.Pipeline unnest(com.google.firebase.firestore.pipeline.Selectable arrayWithAlias) { throw new RuntimeException("Stub!"); } + +/** + * Takes a specified array from the input documents and outputs a document for each element with + * the element stored in a field with name specified by the alias. + * + * For each document emitted by the prior stage, this stage will emit zero or more augmented + * documents. The input array is found in parameter [arrayWithAlias], which can be an [Expr] with + * an alias specified via [Expr.alias], or a [Field] that can also have alias specified. For each + * element of the input array, an augmented document will be produced. The element of input array + * will be stored in a field with name specified by the alias of the [arrayWithAlias] parameter. + * If the [arrayWithAlias] is a [Field] with no alias, then the original array field will be + * replaced with the individual element. + * + * Example: + * ```kotlin + * // Input: + * // { "title": "The Hitchhiker's Guide to the Galaxy", "tags": [ "comedy", "space", "adventure" ], ... } + * + * // Emit a book document for each tag of the book. + * firestore.pipeline().collection("books") + * .unnest("tags", "tag", UnnestOptions().withIndexField("tagIndex")) + * + * // Output: + * // { "title": "The Hitchhiker's Guide to the Galaxy", "tagIndex": 0, "tag": "comedy", ... } + * // { "title": "The Hitchhiker's Guide to the Galaxy", "tagIndex": 1, "tag": "space", ... } + * // { "title": "The Hitchhiker's Guide to the Galaxy", "tagIndex": 2, "tag": "adventure", ... } + * ``` + * + * @param arrayWithAlias The input array with field alias to store output element of array. + * @param options The [UnnestOptions] to use when performing the unnest. + * @return A new [Pipeline] object with this stage appended to the stage list. + */ + +public com.google.firebase.firestore.Pipeline unnest(com.google.firebase.firestore.pipeline.Selectable arrayWithAlias, com.google.firebase.firestore.pipeline.UnnestOptions options) { throw new RuntimeException("Stub!"); } + +/** + * Takes a specified array from the input documents and outputs a document for each element with + * the element stored in a field with name specified by the alias. + * + * For each document emitted by the prior stage, this stage will emit zero or more augmented + * documents. The input array specified in the [unnestStage] parameter will for each element of + * the input array produce an augmented document. The element of the input array will be stored in + * a field with a name specified by the [unnestStage] parameter. + * + * Optionally, an index field can also be added to emitted documents. See [UnnestStage] for + * further information. + * + * @param unnestStage An [UnnestStage] object that specifies the search parameters. + * @return A new [Pipeline] object with this stage appended to the stage list. + */ + +public com.google.firebase.firestore.Pipeline unnest(com.google.firebase.firestore.pipeline.UnnestStage unnestStage) { throw new RuntimeException("Stub!"); } + +/** + * Defines one or more variables in the pipeline's scope. `define` is used to bind a value to a + * variable for internal reuse within the pipeline body (accessed via the `variable()` function). + * + * This stage is particularly useful for passing values from an outer pipeline into a subquery, or + * for declaring reusable intermediate calculations that can be referenced multiple times in later + * parts of the pipeline via `variable()`. + * + * Each variable is defined using an [AliasedExpression], which pairs an expression with a name + * (alias). The expression can be a simple constant, a field reference, or a function evaluation + * (such as a mathematical operation). + * + * Example: + * ```kotlin + * firestore.pipeline().collection("products") + * .define(field("category").alias("productCategory")) + * .addFields( + * firestore.pipeline().collection("categories") + * .where(field("name").equal(variable("productCategory"))) + * .select(field("description")) + * .toScalarExpression().alias("categoryDescription") + * ) + * ``` + * + * @param aliasedExpression The first variable to define, specified as an [AliasedExpression]. + * @param additionalExpressions Optional additional variables to define, specified as + * [AliasedExpression]s. + * @return A new [Pipeline] object with this stage appended to the stage list. + */ + +public com.google.firebase.firestore.Pipeline define(com.google.firebase.firestore.pipeline.AliasedExpression aliasedExpression, com.google.firebase.firestore.pipeline.AliasedExpression... additionalExpressions) { throw new RuntimeException("Stub!"); } + +/** + * Converts this Pipeline into an expression that evaluates to an array of results. + * + * **Result Unwrapping:** + * - If the items have a single field, their values are unwrapped and returned directly in the + * array. + * - If the items have multiple fields, they are returned as Maps in the array. + * + * Example: + * ```kotlin + * // Get a list of reviewers for each book + * db.pipeline().collection("books") + * .define(field("id").alias("book_id")) + * .addFields( + * db.pipeline().collection("reviews") + * .where(field("book_id").equal(variable("book_id"))) + * .select(field("reviewer")) + * .toArrayExpression() + * .alias("reviewers")) + * ``` + * + * Output: + * ```json + * [ + * { + * "id": "1", + * "title": "1984", + * "reviewers": ["Alice", "Bob"] + * } + * ] + * ``` + * + * Example (Multiple Fields): + * ```kotlin + * // Get a list of reviews (reviewer and rating) for each book + * db.pipeline().collection("books") + * .define(field("id").alias("book_id")) + * .addFields( + * db.pipeline().collection("reviews") + * .where(field("book_id").equal(variable("book_id"))) + * .select(field("reviewer"), field("rating")) + * .toArrayExpression() + * .alias("reviews")) + * ``` + * + * *When the subquery produces multiple fields, they are kept as objects in the array:* + * + * Output: + * ```json + * [ + * { + * "id": "1", + * "title": "1984", + * "reviews": [ + * { "reviewer": "Alice", "rating": 5 }, + * { "reviewer": "Bob", "rating": 4 } + * ] + * } + * ] + * ``` + * + * @return An [Expression] that executes this pipeline and returns the results as a list. + */ + +public com.google.firebase.firestore.pipeline.Expression toArrayExpression() { throw new RuntimeException("Stub!"); } + +/** + * Converts this Pipeline into an expression that evaluates to a single scalar result. + * + * **Runtime Validation:** The runtime validates that the result set contains zero or one item. If + * zero items, it evaluates to `null`. + * + * **Result Unwrapping:** If the result contains exactly one item: + * - If the item has a single field, its value is unwrapped and returned directly. + * - If the item has multiple fields, they are returned as a Map. + * + * Example: + * ```kotlin + * // Calculate average rating for a restaurant + * db.pipeline().collection("restaurants") + * .define(field("id").alias("rid")) + * .addFields( + * db.pipeline().collection("reviews") + * .where(field("restaurant_id").equal(variable("rid"))) + * .aggregate(AggregateFunction.average("rating").alias("avg")) + * // Unwraps the single "avg" field to a scalar double + * .toScalarExpression().alias("average_rating") + * ) + * ``` + * + * Output: + * ```json + * { + * "name": "The Burger Joint", + * "average_rating": 4.5 + * } + * ``` + * + * Example (Multiple Fields): + * ```kotlin + * // Calculate average rating AND count for a restaurant + * db.pipeline().collection("restaurants") + * .define(field("id").alias("rid")) + * .addFields( + * db.pipeline().collection("reviews") + * .where(field("restaurant_id").equal(variable("rid"))) + * .aggregate( + * AggregateFunction.average("rating").alias("avg"), + * AggregateFunction.count().alias("count") + * ) + * // Returns a Map with "avg" and "count" fields + * .toScalarExpression().alias("stats") + * ) + * ``` + * + * Output: + * ```json + * { + * "name": "The Burger Joint", + * "stats": { + * "avg": 4.5, + * "count": 100 + * } + * } + * ``` + * + * @return An [Expression] representing the scalar result. + */ + +public com.google.firebase.firestore.pipeline.Expression toScalarExpression() { throw new RuntimeException("Stub!"); } + +/** + * Add a search stage to the Pipeline. + * + * Note: This must be the first stage of the pipeline. + * + * A limited set of expressions are supported in the search stage. + * + * @example + * ```kotlin + * db.pipeline().collection("restaurants").search( + * SearchStage( + * query = documentMatches("waffles OR pancakes"), + * sort = arrayOf(score().descending()) + * ) + * ) + * ``` + * + * @param searchStage An object that specifies how search is performed. + * @return A new `Pipeline` object with this stage appended to the stage list. + */ + +public com.google.firebase.firestore.Pipeline search(com.google.firebase.firestore.pipeline.SearchStage searchStage) { throw new RuntimeException("Stub!"); } +@SuppressWarnings({"unchecked", "deprecation", "all"}) +public static final class ExecuteOptions extends com.google.firebase.firestore.pipeline.AbstractOptions { + +public ExecuteOptions() { super(null); throw new RuntimeException("Stub!"); } + +public com.google.firebase.firestore.Pipeline.ExecuteOptions self(com.google.firebase.firestore.pipeline.InternalOptions options) { throw new RuntimeException("Stub!"); } + +public com.google.firebase.firestore.Pipeline.ExecuteOptions withIndexMode(com.google.firebase.firestore.Pipeline.ExecuteOptions.IndexMode indexMode) { throw new RuntimeException("Stub!"); } +@SuppressWarnings({"unchecked", "deprecation", "all"}) +public static final class IndexMode { + +IndexMode() { throw new RuntimeException("Stub!"); } + +public static final com.google.firebase.firestore.Pipeline.ExecuteOptions.IndexMode.Companion Companion; +static { Companion = null; } + +public static final com.google.firebase.firestore.Pipeline.ExecuteOptions.IndexMode RECOMMENDED; +static { RECOMMENDED = null; } +@SuppressWarnings({"unchecked", "deprecation", "all"}) +public static final class Companion { + +Companion() { throw new RuntimeException("Stub!"); } +} + +} + +} + +/** + * A `Snapshot` contains the results of a pipeline execution. It can be iterated to retrieve the + * individual `PipelineResult` objects. + */ + +@SuppressWarnings({"unchecked", "deprecation", "all"}) +public static final class Snapshot implements java.lang.Iterable, kotlin.jvm.internal.markers.KMappedMarker { + +Snapshot() { throw new RuntimeException("Stub!"); } + +/** The time at which the pipeline producing this result is executed. */ + +public com.google.firebase.Timestamp getExecutionTime() { throw new RuntimeException("Stub!"); } + +/** List of all the results */ + +public java.util.List getResults() { throw new RuntimeException("Stub!"); } + +public java.util.Iterator iterator() { throw new RuntimeException("Stub!"); } + +public java.lang.String toString() { throw new RuntimeException("Stub!"); } + +public boolean equals(java.lang.Object other) { throw new RuntimeException("Stub!"); } + +public int hashCode() { throw new RuntimeException("Stub!"); } +} + +} + + + +// File: PipelineResult.java +// Copyright 2025 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file 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. +// Validate document path by converting to DocumentReference +package com.google.firebase.firestore; + + +/** + * Represents the results of a Pipeline query, including the data and metadata. It is usually + * accessed via [Pipeline.Snapshot]. + */ + +@SuppressWarnings({"unchecked", "deprecation", "all"}) +public final class PipelineResult { + +PipelineResult() { throw new RuntimeException("Stub!"); } + +/** The time the document was created. Null if this result is not a document. */ + +public com.google.firebase.Timestamp getCreateTime() { throw new RuntimeException("Stub!"); } + +/** + * The time the document was last updated (at the time the snapshot was generated). Null if this + * result is not a document. + */ + +public com.google.firebase.Timestamp getUpdateTime() { throw new RuntimeException("Stub!"); } + +/** + * The reference to the document, if the query returns the document id for a document. The name + * field will be returned by default if querying a document. + * + * Document ids will not be returned if certain pipeline stages omit the document id. For example, + * [Pipeline.select], [Pipeline.removeFields] and [Pipeline.aggregate] can omit the document id. + * + * @return [DocumentReference] Reference to the document, if applicable. + */ + +public com.google.firebase.firestore.DocumentReference getRef() { throw new RuntimeException("Stub!"); } + +/** + * Returns the ID of the document represented by this result. Returns null if this result is not + * corresponding to a Firestore document. + * + * @return ID of document, if applicable. + */ + +public java.lang.String getId() { throw new RuntimeException("Stub!"); } + +/** + * Retrieves all fields in the result as an object map. + * + * @return Map of field names to objects. + */ + +public java.util.Map getData() { throw new RuntimeException("Stub!"); } + +/** + * Retrieves the field specified by [field]. + * + * @param field The field path (e.g. "foo" or "foo.bar") to a specific field. + * @return The data at the specified field location or null if no such field exists. + */ + +public java.lang.Object get(java.lang.String field) { throw new RuntimeException("Stub!"); } + +/** + * Retrieves the field specified by [fieldPath]. + * + * @param fieldPath The field path to a specific field. + * @return The data at the specified field location or null if no such field exists. + */ + +public java.lang.Object get(com.google.firebase.firestore.FieldPath fieldPath) { throw new RuntimeException("Stub!"); } + +public java.lang.String toString() { throw new RuntimeException("Stub!"); } + +public boolean equals(java.lang.Object other) { throw new RuntimeException("Stub!"); } + +public int hashCode() { throw new RuntimeException("Stub!"); } +} + + + +// File: PipelineSource.java +// Copyright 2025 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file 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. +// Validate document path by converting to DocumentReference +package com.google.firebase.firestore; + + +/** Start of a Firestore Pipeline */ + +@SuppressWarnings({"unchecked", "deprecation", "all"}) +public final class PipelineSource { + +PipelineSource() { throw new RuntimeException("Stub!"); } + +/** + * Convert the given Query into an equivalent Pipeline. + * + * @param query A Query to be converted into a Pipeline. + * @return A new [Pipeline] object that is equivalent to [query] + * @throws [IllegalArgumentException] Thrown if the [query] provided targets a different project + * or database than the pipeline. + */ + +public com.google.firebase.firestore.Pipeline createFrom(com.google.firebase.firestore.Query query) { throw new RuntimeException("Stub!"); } + +/** + * Convert the given Aggregate Query into an equivalent Pipeline. + * + * @param aggregateQuery An Aggregate Query to be converted into a Pipeline. + * @return A new [Pipeline] object that is equivalent to [aggregateQuery] + * @throws [IllegalArgumentException] Thrown if the [aggregateQuery] provided targets a different + * project or database than the pipeline. + */ + +public com.google.firebase.firestore.Pipeline createFrom(com.google.firebase.firestore.AggregateQuery aggregateQuery) { throw new RuntimeException("Stub!"); } + +/** + * Set the pipeline's source to the collection specified by the given path. + * + * @param path A path to a collection that will be the source of this pipeline. + * @return A new [Pipeline] object with documents from target collection. + */ + +public com.google.firebase.firestore.Pipeline collection(java.lang.String path) { throw new RuntimeException("Stub!"); } + +/** + * Set the pipeline's source to the collection specified by the given [CollectionReference]. + * + * @param ref A [CollectionReference] for a collection that will be the source of this pipeline. + * @return A new [Pipeline] object with documents from target collection. + * @throws [IllegalArgumentException] Thrown if the [ref] provided targets a different project or + * database than the pipeline. + */ + +public com.google.firebase.firestore.Pipeline collection(com.google.firebase.firestore.CollectionReference ref) { throw new RuntimeException("Stub!"); } + +/** + * Set the pipeline's source to the collection specified by the given [CollectionReference]. + * + * @param ref A [CollectionReference] for a collection that will be the source of this pipeline. + * @param options [CollectionSourceOptions] for the collection. + * @return A new [Pipeline] object with documents from target collection. + * @throws [IllegalArgumentException] Thrown if the [ref] provided targets a different project or + * database than the pipeline. + */ + +public com.google.firebase.firestore.Pipeline collection(com.google.firebase.firestore.CollectionReference ref, com.google.firebase.firestore.pipeline.CollectionSourceOptions options) { throw new RuntimeException("Stub!"); } + +/** + * Set the pipeline's source to the collection group with the given id. + * + * @param collectionId The id of a collection group that will be the source of this pipeline. + * @return A new [Pipeline] object with documents from target collection group. + */ + +public com.google.firebase.firestore.Pipeline collectionGroup(java.lang.String collectionId) { throw new RuntimeException("Stub!"); } + +/** + * Set the pipeline's source to the collection group with the given id. + * + * @param collectionId The id of a collection group that will be the source of this pipeline. + * @param options [CollectionGroupOptions] for the collection group. + * @return A new [Pipeline] object with documents from target collection group. + */ + +public com.google.firebase.firestore.Pipeline collectionGroup(java.lang.String collectionId, com.google.firebase.firestore.pipeline.CollectionGroupOptions options) { throw new RuntimeException("Stub!"); } + +/** + * Set the pipeline's source to be all documents in this database. + * + * @return A new [Pipeline] object with all documents in this database. + */ + +public com.google.firebase.firestore.Pipeline database() { throw new RuntimeException("Stub!"); } + +/** + * Set the pipeline's source to the documents specified by the given paths. + * + * @param documents Paths specifying the individual documents that will be the source of this + * pipeline. + * @return A new [Pipeline] object with [documents]. + */ + +public com.google.firebase.firestore.Pipeline documents(java.lang.String... documents) { throw new RuntimeException("Stub!"); } + +/** + * Set the pipeline's source to the documents specified by the given DocumentReferences. + * + * @param documents DocumentReferences specifying the individual documents that will be the source + * of this pipeline. + * @return Pipeline with [documents]. + * @throws [IllegalArgumentException] Thrown if the [documents] provided targets a different + * project or database than the pipeline. + */ + +public com.google.firebase.firestore.Pipeline documents(com.google.firebase.firestore.DocumentReference... documents) { throw new RuntimeException("Stub!"); } + +/** + * Initializes a pipeline scoped to a subcollection. + * + * This method allows you to start a new pipeline that operates on a subcollection of the + * current document. It is intended to be used as a subquery. + * + * **Note:** A pipeline created with `subcollection` cannot be executed directly. It must be + * used within a parent pipeline. + * + * Example: + * ```kotlin + * firestore.pipeline().collection("books") + * .addFields( + * PipelineSource.subcollection("reviews") + * .aggregate(AggregateFunction.average("rating").as("avg_rating")) + * .toScalarExpression().as("average_rating")) + * ``` + * + * @param path The path of the subcollection. + * @return A new [Pipeline] instance scoped to the subcollection. + */ + +public static com.google.firebase.firestore.Pipeline subcollection(java.lang.String path) { throw new RuntimeException("Stub!"); } + +/** + * Creates a pipeline that processes the documents in the specified subcollection of the current + * document. + * + * Example: + * ```kotlin + * firestore.pipeline().collection("books") + * .addFields( + * PipelineSource.subcollection(SubcollectionSource.of("reviews")) + * .aggregate(AggregateFunction.average("rating").as("avg_rating")) + * .toScalarExpression().as("average_rating")) + * ``` + * + * @param source The subcollection that will be the source of this pipeline. + * @return A new [Pipeline] scoped to the subcollection. + */ + +public static com.google.firebase.firestore.Pipeline subcollection(com.google.firebase.firestore.pipeline.SubcollectionSource source) { throw new RuntimeException("Stub!"); } + +public static final com.google.firebase.firestore.PipelineSource.Companion Companion; +static { Companion = null; } +@SuppressWarnings({"unchecked", "deprecation", "all"}) +public static final class Companion { + +Companion() { throw new RuntimeException("Stub!"); } + +/** + * Initializes a pipeline scoped to a subcollection. + * + * This method allows you to start a new pipeline that operates on a subcollection of the + * current document. It is intended to be used as a subquery. + * + * **Note:** A pipeline created with `subcollection` cannot be executed directly. It must be + * used within a parent pipeline. + * + * Example: + * ```kotlin + * firestore.pipeline().collection("books") + * .addFields( + * PipelineSource.subcollection("reviews") + * .aggregate(AggregateFunction.average("rating").as("avg_rating")) + * .toScalarExpression().as("average_rating")) + * ``` + * + * @param path The path of the subcollection. + * @return A new [Pipeline] instance scoped to the subcollection. + */ + +public com.google.firebase.firestore.Pipeline subcollection(java.lang.String path) { throw new RuntimeException("Stub!"); } + +/** + * Creates a pipeline that processes the documents in the specified subcollection of the current + * document. + * + * Example: + * ```kotlin + * firestore.pipeline().collection("books") + * .addFields( + * PipelineSource.subcollection(SubcollectionSource.of("reviews")) + * .aggregate(AggregateFunction.average("rating").as("avg_rating")) + * .toScalarExpression().as("average_rating")) + * ``` + * + * @param source The subcollection that will be the source of this pipeline. + * @return A new [Pipeline] scoped to the subcollection. + */ + +public com.google.firebase.firestore.Pipeline subcollection(com.google.firebase.firestore.pipeline.SubcollectionSource source) { throw new RuntimeException("Stub!"); } +} + +} + + + diff --git a/plugins/src/main/java/com/google/firebase/gradle/plugins/Metalava.kt b/plugins/src/main/java/com/google/firebase/gradle/plugins/Metalava.kt index 64a367e7c8a..67361aeb63e 100644 --- a/plugins/src/main/java/com/google/firebase/gradle/plugins/Metalava.kt +++ b/plugins/src/main/java/com/google/firebase/gradle/plugins/Metalava.kt @@ -117,14 +117,26 @@ abstract class GenerateApiTxtTask @Inject constructor(private val execOperations @get:OutputFile abstract val baselineFile: RegularFileProperty + @get:org.gradle.api.tasks.Optional + @get:org.gradle.api.tasks.OutputDirectory + val assetDocsDir: File? + get() = if (project.name == "firebase-firestore") project.file("src/main/assets") else null + @get:Input abstract val updateBaseline: Property @TaskAction fun run() { val sourcePath = sources.files.filter { it.exists() }.map { it.absolutePath }.joinToString(":") - val classPath = classPath.files.asSequence().map { it.absolutePath }.toMutableList() - project.androidJar?.let { classPath += listOf(it.absolutePath) } + val classPathList = classPath.files.asSequence().map { it.absolutePath }.toMutableList() + project.androidJar?.let { classPathList += listOf(it.absolutePath) } + + if (project.name == "firebase-firestore") { + val compiledDebug = project.file("build/tmp/kotlin-classes/debug") + val compiledRelease = project.file("build/tmp/kotlin-classes/release") + if (compiledDebug.exists()) classPathList += listOf(compiledDebug.absolutePath) + if (compiledRelease.exists()) classPathList += listOf(compiledRelease.absolutePath) + } project.runMetalavaWithArgs( execOperations, @@ -132,7 +144,7 @@ abstract class GenerateApiTxtTask @Inject constructor(private val execOperations "--source-path", sourcePath, "--classpath", - classPath.joinToString(":"), + classPathList.joinToString(":"), "--api", apiTxtFile.get().asFile.absolutePath, "--format=v3", @@ -143,6 +155,74 @@ abstract class GenerateApiTxtTask @Inject constructor(private val execOperations else listOf(), ignoreFailure = true, ) + + if (project.name == "firebase-firestore") { + val classPathString = classPathList.joinToString(":") + val fsSourcePath = project.file("src/main/java").absolutePath + + generateAssetDocs( + targetFiles = + listOf(project.file("src/main/java/com/google/firebase/firestore/Pipeline.kt")), + stubDirName = "doc-stubs-pipeline", + outputFileName = "pipeline.docs.txt", + classPathString = classPathString, + sourcePath = fsSourcePath, + ) + + generateAssetDocs( + targetFiles = + listOf( + project.file("src/main/java/com/google/firebase/firestore/pipeline/expressions.kt"), + project.file("src/main/java/com/google/firebase/firestore/pipeline/aggregates.kt"), + ), + stubDirName = "doc-stubs-expressions", + outputFileName = "expressions.docs.txt", + classPathString = classPathString, + sourcePath = fsSourcePath, + ) + } + } + + private fun generateAssetDocs( + targetFiles: List, + stubDirName: String, + outputFileName: String, + classPathString: String, + sourcePath: String, + ) { + val docStubsDir = project.file("${project.layout.buildDirectory.get().asFile}/$stubDirName") + docStubsDir.deleteRecursively() + + project.runMetalavaWithArgs( + execOperations, + listOf( + "--source-path", + sourcePath, + "--source-files", + targetFiles.joinToString(",") { it.absolutePath }, + "--classpath", + classPathString, + "--doc-stubs", + docStubsDir.absolutePath, + "--format=v3", + ), + ignoreFailure = false, + ) + + val assetsDocsFile = project.file("src/main/assets/$outputFileName") + project.file("src/main/assets").mkdirs() + val content = buildString { + docStubsDir + .walkTopDown() + .filter { it.isFile && (it.extension == "java" || it.extension == "kt") } + .sortedBy { it.name } + .forEach { f -> + append("// File: ${f.name}\n") + append(f.readText()) + append("\n\n") + } + } + assetsDocsFile.writeText(content) } } From b2d782fe80cd0b66a3bf1d17ca8b9db36401eda8 Mon Sep 17 00:00:00 2001 From: wu-hui Date: Fri, 22 May 2026 12:20:30 -0400 Subject: [PATCH 2/2] feat(firestore): Publish documentation stubs inside the standard Maven sources jar instead of runtime assets --- .../src/main/assets/expressions.docs.txt | 19833 ---------------- .../src/main/assets/pipeline.docs.txt | 1294 - .../plugins/BaseFirebaseLibraryPlugin.kt | 23 +- .../firebase/gradle/plugins/Metalava.kt | 20 +- 4 files changed, 29 insertions(+), 21141 deletions(-) delete mode 100644 firebase-firestore/src/main/assets/expressions.docs.txt delete mode 100644 firebase-firestore/src/main/assets/pipeline.docs.txt diff --git a/firebase-firestore/src/main/assets/expressions.docs.txt b/firebase-firestore/src/main/assets/expressions.docs.txt deleted file mode 100644 index fc8770df5bd..00000000000 --- a/firebase-firestore/src/main/assets/expressions.docs.txt +++ /dev/null @@ -1,19833 +0,0 @@ -// File: AggregateFunction.java -// Copyright 2025 Google LLC -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file 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. -package com.google.firebase.firestore.pipeline; - - -/** A class that represents an aggregate function. */ - -@SuppressWarnings({"unchecked", "deprecation", "all"}) -public final class AggregateFunction { - -AggregateFunction() { throw new RuntimeException("Stub!"); } - -/** - * Assigns an alias to this aggregate. - * - * @param alias The alias to assign to this aggregate. - * @return A new [AliasedAggregate] that wraps this aggregate and associates it with the provided - * alias. - */ - -public com.google.firebase.firestore.pipeline.AliasedAggregate alias(java.lang.String alias) { throw new RuntimeException("Stub!"); } - -/** - * Creates a raw aggregation function. - * - * This method provides a way to call aggregation functions that are supported by the Firestore - * backend but that are not available as specific factory methods in this class. - * - * @param name The name of the aggregation function. - * @param expr The expressions to pass as arguments to the function. - * @return A new [AggregateFunction] for the specified function. - */ - -public static com.google.firebase.firestore.pipeline.AggregateFunction rawAggregate(java.lang.String name, com.google.firebase.firestore.pipeline.Expression... expr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that counts the total number of stage inputs. - * - * @return A new [AggregateFunction] representing the countAll aggregation. - */ - -public static com.google.firebase.firestore.pipeline.AggregateFunction countAll() { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that counts the number of stage inputs where the input field exists. - * - * @param fieldName The name of the field to count. - * @return A new [AggregateFunction] representing the 'count' aggregation. - */ - -public static com.google.firebase.firestore.pipeline.AggregateFunction count(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that counts the number of stage inputs with valid evaluations of the - * provided [expression]. - * - * @param expression The expression to count. - * @return A new [AggregateFunction] representing the 'count' aggregation. - */ - -public static com.google.firebase.firestore.pipeline.AggregateFunction count(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that counts the number of stage inputs where the provided boolean - * expression evaluates to true. - * - * @param condition The boolean expression to evaluate on each input. - * @return A new [AggregateFunction] representing the count aggregation. - */ - -public static com.google.firebase.firestore.pipeline.AggregateFunction countIf(com.google.firebase.firestore.pipeline.BooleanExpression condition) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that calculates the sum of a field's values across multiple stage - * inputs. - * - * @param fieldName The name of the field containing numeric values to sum up. - * @return A new [AggregateFunction] representing the sum aggregation. - */ - -public static com.google.firebase.firestore.pipeline.AggregateFunction sum(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that calculates the sum of values from an expression across multiple - * stage inputs. - * - * @param expression The expression to sum up. - * @return A new [AggregateFunction] representing the sum aggregation. - */ - -public static com.google.firebase.firestore.pipeline.AggregateFunction sum(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that calculates the average (mean) of a field's values across multiple - * stage inputs. - * - * @param fieldName The name of the field containing numeric values to average. - * @return A new [AggregateFunction] representing the average aggregation. - */ - -public static com.google.firebase.firestore.pipeline.AggregateFunction average(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that calculates the average (mean) of values from an expression across - * multiple stage inputs. - * - * @param expression The expression representing the values to average. - * @return A new [AggregateFunction] representing the average aggregation. - */ - -public static com.google.firebase.firestore.pipeline.AggregateFunction average(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that finds the minimum value of a field across multiple stage inputs. - * - * @param fieldName The name of the field to find the minimum value of. - * @return A new [AggregateFunction] representing the minimum aggregation. - */ - -public static com.google.firebase.firestore.pipeline.AggregateFunction minimum(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that finds the minimum value of an expression across multiple stage - * inputs. - * - * @param expression The expression to find the minimum value of. - * @return A new [AggregateFunction] representing the minimum aggregation. - */ - -public static com.google.firebase.firestore.pipeline.AggregateFunction minimum(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that finds the maximum value of a field across multiple stage inputs. - * - * @param fieldName The name of the field to find the maximum value of. - * @return A new [AggregateFunction] representing the maximum aggregation. - */ - -public static com.google.firebase.firestore.pipeline.AggregateFunction maximum(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that finds the maximum value of an expression across multiple stage - * inputs. - * - * @param expression The expression to find the maximum value of. - * @return A new [AggregateFunction] representing the maximum aggregation. - */ - -public static com.google.firebase.firestore.pipeline.AggregateFunction maximum(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that counts the number of distinct values of a field across multiple - * stage inputs. - * - * @param fieldName The name of the field to count the distinct values of. - * @return A new [AggregateFunction] representing the count distinct aggregation. - */ - -public static com.google.firebase.firestore.pipeline.AggregateFunction countDistinct(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that counts the number of distinct values of an expression across - * multiple stage inputs. - * - * @param expression The expression to count the distinct values of. - * @return A new [AggregateFunction] representing the count distinct aggregation. - */ - -public static com.google.firebase.firestore.pipeline.AggregateFunction countDistinct(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that finds the first value of a field across multiple stage inputs. - * - * @param fieldName The name of the field to find the first value of. - * @return A new [AggregateFunction] representing the first aggregation. - */ - -public static com.google.firebase.firestore.pipeline.AggregateFunction first(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that finds the first value of an expression across multiple stage - * inputs. - * - * @param expression The expression to find the first value of. - * @return A new [AggregateFunction] representing the first aggregation. - */ - -public static com.google.firebase.firestore.pipeline.AggregateFunction first(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that finds the last value of a field across multiple stage inputs. - * - * @param fieldName The name of the field to find the last value of. - * @return A new [AggregateFunction] representing the last aggregation. - */ - -public static com.google.firebase.firestore.pipeline.AggregateFunction last(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that finds the last value of an expression across multiple stage - * inputs. - * - * @param expression The expression to find the last value of. - * @return A new [AggregateFunction] representing the last aggregation. - */ - -public static com.google.firebase.firestore.pipeline.AggregateFunction last(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that collects all values of a field across multiple stage inputs into - * an array. - * - * If the expression resolves to an absent value, it is converted to `null`. The order of - * elements in the output array is not stable and shouldn't be relied upon. - * - * @param fieldName The name of the field to collect values from. - * @return A new [AggregateFunction] representing the array_agg aggregation. - */ - -public static com.google.firebase.firestore.pipeline.AggregateFunction arrayAgg(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that collects all values of an expression across multiple stage inputs - * into an array. - * - * If the expression resolves to an absent value, it is converted to `null`. The order of - * elements in the output array is not stable and shouldn't be relied upon. - * - * @param expression The expression to collect values from. - * @return A new [AggregateFunction] representing the array_agg aggregation. - */ - -public static com.google.firebase.firestore.pipeline.AggregateFunction arrayAgg(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that collects all distinct values of a field across multiple stage - * inputs into an array. - * - * If the expression resolves to an absent value, it is converted to `null`. The order of - * elements in the output array is not stable and shouldn't be relied upon. - * - * @param fieldName The name of the field to collect values from. - * @return A new [AggregateFunction] representing the array_agg_distinct aggregation. - */ - -public static com.google.firebase.firestore.pipeline.AggregateFunction arrayAggDistinct(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that collects all distinct values of an expression across multiple - * stage inputs into an array. - * - * If the expression resolves to an absent value, it is converted to `null`. The order of - * elements in the output array is not stable and shouldn't be relied upon. - * - * @param expression The expression to collect values from. - * @return A new [AggregateFunction] representing the array_agg_distinct aggregation. - */ - -public static com.google.firebase.firestore.pipeline.AggregateFunction arrayAggDistinct(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } - -public static final com.google.firebase.firestore.pipeline.AggregateFunction.Companion Companion; -static { Companion = null; } -@SuppressWarnings({"unchecked", "deprecation", "all"}) -public static final class Companion { - -Companion() { throw new RuntimeException("Stub!"); } - -/** - * Creates a raw aggregation function. - * - * This method provides a way to call aggregation functions that are supported by the Firestore - * backend but that are not available as specific factory methods in this class. - * - * @param name The name of the aggregation function. - * @param expr The expressions to pass as arguments to the function. - * @return A new [AggregateFunction] for the specified function. - */ - -public com.google.firebase.firestore.pipeline.AggregateFunction rawAggregate(java.lang.String name, com.google.firebase.firestore.pipeline.Expression... expr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that counts the total number of stage inputs. - * - * @return A new [AggregateFunction] representing the countAll aggregation. - */ - -public com.google.firebase.firestore.pipeline.AggregateFunction countAll() { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that counts the number of stage inputs where the input field exists. - * - * @param fieldName The name of the field to count. - * @return A new [AggregateFunction] representing the 'count' aggregation. - */ - -public com.google.firebase.firestore.pipeline.AggregateFunction count(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that counts the number of stage inputs with valid evaluations of the - * provided [expression]. - * - * @param expression The expression to count. - * @return A new [AggregateFunction] representing the 'count' aggregation. - */ - -public com.google.firebase.firestore.pipeline.AggregateFunction count(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that counts the number of stage inputs where the provided boolean - * expression evaluates to true. - * - * @param condition The boolean expression to evaluate on each input. - * @return A new [AggregateFunction] representing the count aggregation. - */ - -public com.google.firebase.firestore.pipeline.AggregateFunction countIf(com.google.firebase.firestore.pipeline.BooleanExpression condition) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that calculates the sum of a field's values across multiple stage - * inputs. - * - * @param fieldName The name of the field containing numeric values to sum up. - * @return A new [AggregateFunction] representing the sum aggregation. - */ - -public com.google.firebase.firestore.pipeline.AggregateFunction sum(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that calculates the sum of values from an expression across multiple - * stage inputs. - * - * @param expression The expression to sum up. - * @return A new [AggregateFunction] representing the sum aggregation. - */ - -public com.google.firebase.firestore.pipeline.AggregateFunction sum(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that calculates the average (mean) of a field's values across multiple - * stage inputs. - * - * @param fieldName The name of the field containing numeric values to average. - * @return A new [AggregateFunction] representing the average aggregation. - */ - -public com.google.firebase.firestore.pipeline.AggregateFunction average(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that calculates the average (mean) of values from an expression across - * multiple stage inputs. - * - * @param expression The expression representing the values to average. - * @return A new [AggregateFunction] representing the average aggregation. - */ - -public com.google.firebase.firestore.pipeline.AggregateFunction average(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that finds the minimum value of a field across multiple stage inputs. - * - * @param fieldName The name of the field to find the minimum value of. - * @return A new [AggregateFunction] representing the minimum aggregation. - */ - -public com.google.firebase.firestore.pipeline.AggregateFunction minimum(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that finds the minimum value of an expression across multiple stage - * inputs. - * - * @param expression The expression to find the minimum value of. - * @return A new [AggregateFunction] representing the minimum aggregation. - */ - -public com.google.firebase.firestore.pipeline.AggregateFunction minimum(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that finds the maximum value of a field across multiple stage inputs. - * - * @param fieldName The name of the field to find the maximum value of. - * @return A new [AggregateFunction] representing the maximum aggregation. - */ - -public com.google.firebase.firestore.pipeline.AggregateFunction maximum(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that finds the maximum value of an expression across multiple stage - * inputs. - * - * @param expression The expression to find the maximum value of. - * @return A new [AggregateFunction] representing the maximum aggregation. - */ - -public com.google.firebase.firestore.pipeline.AggregateFunction maximum(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that counts the number of distinct values of a field across multiple - * stage inputs. - * - * @param fieldName The name of the field to count the distinct values of. - * @return A new [AggregateFunction] representing the count distinct aggregation. - */ - -public com.google.firebase.firestore.pipeline.AggregateFunction countDistinct(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that counts the number of distinct values of an expression across - * multiple stage inputs. - * - * @param expression The expression to count the distinct values of. - * @return A new [AggregateFunction] representing the count distinct aggregation. - */ - -public com.google.firebase.firestore.pipeline.AggregateFunction countDistinct(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that finds the first value of a field across multiple stage inputs. - * - * @param fieldName The name of the field to find the first value of. - * @return A new [AggregateFunction] representing the first aggregation. - */ - -public com.google.firebase.firestore.pipeline.AggregateFunction first(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that finds the first value of an expression across multiple stage - * inputs. - * - * @param expression The expression to find the first value of. - * @return A new [AggregateFunction] representing the first aggregation. - */ - -public com.google.firebase.firestore.pipeline.AggregateFunction first(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that finds the last value of a field across multiple stage inputs. - * - * @param fieldName The name of the field to find the last value of. - * @return A new [AggregateFunction] representing the last aggregation. - */ - -public com.google.firebase.firestore.pipeline.AggregateFunction last(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that finds the last value of an expression across multiple stage - * inputs. - * - * @param expression The expression to find the last value of. - * @return A new [AggregateFunction] representing the last aggregation. - */ - -public com.google.firebase.firestore.pipeline.AggregateFunction last(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that collects all values of a field across multiple stage inputs into - * an array. - * - * If the expression resolves to an absent value, it is converted to `null`. The order of - * elements in the output array is not stable and shouldn't be relied upon. - * - * @param fieldName The name of the field to collect values from. - * @return A new [AggregateFunction] representing the array_agg aggregation. - */ - -public com.google.firebase.firestore.pipeline.AggregateFunction arrayAgg(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that collects all values of an expression across multiple stage inputs - * into an array. - * - * If the expression resolves to an absent value, it is converted to `null`. The order of - * elements in the output array is not stable and shouldn't be relied upon. - * - * @param expression The expression to collect values from. - * @return A new [AggregateFunction] representing the array_agg aggregation. - */ - -public com.google.firebase.firestore.pipeline.AggregateFunction arrayAgg(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that collects all distinct values of a field across multiple stage - * inputs into an array. - * - * If the expression resolves to an absent value, it is converted to `null`. The order of - * elements in the output array is not stable and shouldn't be relied upon. - * - * @param fieldName The name of the field to collect values from. - * @return A new [AggregateFunction] representing the array_agg_distinct aggregation. - */ - -public com.google.firebase.firestore.pipeline.AggregateFunction arrayAggDistinct(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that collects all distinct values of an expression across multiple - * stage inputs into an array. - * - * If the expression resolves to an absent value, it is converted to `null`. The order of - * elements in the output array is not stable and shouldn't be relied upon. - * - * @param expression The expression to collect values from. - * @return A new [AggregateFunction] representing the array_agg_distinct aggregation. - */ - -public com.google.firebase.firestore.pipeline.AggregateFunction arrayAggDistinct(com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } -} - -} - - - -// File: AliasedAggregate.java -// Copyright 2025 Google LLC -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file 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. -package com.google.firebase.firestore.pipeline; - - -@SuppressWarnings({"unchecked", "deprecation", "all"}) -public final class AliasedAggregate { - -AliasedAggregate() { throw new RuntimeException("Stub!"); } -} - - - -// File: AliasedExpression.java -// Copyright 2025 Google LLC -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file 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. -// Ensure this overload exists or is correctly placed -// /** -// * Perform a full-text search on the specified field. -// * -// * Note: This Expression can only be used within a `Search` stage. -// * -// * @example -// * ```kotlin -// * db.pipeline().collection("restaurants").search( -// * SearchStage(query = matches("menu", "waffles")) -// * ) -// * ``` -// * -// * @param fieldName Perform search on this field. -// * @param rquery Define the search query using the search DSL. -// */ -// // TODO(search) this is internal until supported by the backend -// @Beta -// @JvmStatic -// internal fun matches(fieldName: String, rquery: String): BooleanExpression = -// matches(field(fieldName), rquery) -// -// /** -// * Perform a full-text search on the specified field. -// * -// * Note: This Expression can only be used within a `Search` stage. -// * -// * @example -// * ```kotlin -// * db.pipeline().collection("restaurants").search( -// * SearchStage(query = matches(field("menu"), "waffles")) -// * ) -// * ``` -// * -// * @param field Perform search on this field. -// * @param rquery Define the search query using the search DSL. -// */ -// // TODO(search) this is internal until supported by the backend -// @Beta -// @JvmStatic -// internal fun matches(field: Field, rquery: String): BooleanExpression = -// BooleanFunctionExpression("matches", notImplemented, field, constant(rquery)) -// /** -// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search -// query -// * in `bold`. -// * -// * This Expression can only be used within a `Search` stage. -// * -// * @example -// * ```kotlin -// * db.pipeline().collection("restaurants").search( -// * SearchStage(query = documentMatches("waffles"), addFields = arrayOf(snippet("menu", -// "waffles").alias("snippet"))) -// * ) -// * ``` -// * -// * @param fieldName Search the specified field for matching terms. -// * @param rquery Define the search query using the search DSL. -// */ -// @Beta -// @JvmStatic -// fun snippet(fieldName: String, rquery: String): Expression = -// FunctionExpression("snippet", notImplemented, field(fieldName), constant(rquery)) -// /** -// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search -// query -// * in `bold`. -// * -// * This Expression can only be used within a `Search` stage. -// * -// * @param fieldName Search the specified field for matching terms. -// * @param options Define how the snippet is generated. -// */ -// // TODO(search) snippet with options is internal and unimplemented until supported by the -// // backend -// @Beta -// @JvmStatic -// internal fun snippet(fieldName: String, options: SnippetOptions): Expression { -// throw NotImplementedError("Not implemented") -// } -// /** -// * Evaluates if the value in the field specified by `fieldName` is between the evaluated -// values -// * for `lowerBound` (inclusive) and `upperBound` (inclusive). -// * -// * @param fieldName Determine if this field is between two bounds. -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// */ -// // TODO(search) between is internal and unimplemented until supported by the backend -// @JvmStatic -// internal fun between( -// fieldName: String, -// lowerBound: Expression, -// upperBound: Expression -// ): BooleanExpression = -// BooleanFunctionExpression("between", notImplemented, fieldName, lowerBound, upperBound) -// /** -// * Evaluates if the value in the field specified by `fieldName` is between the values for -// * `lowerBound` (inclusive) and `upperBound` (inclusive). -// * -// * @param fieldName Determine if this field is between two bounds. -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// */ -// @JvmStatic -// internal fun between(fieldName: String, lowerBound: Any, upperBound: Any): -// BooleanExpression = -// between(fieldName, toExprOrConstant(lowerBound), toExprOrConstant(upperBound)) -// /** -// * Evaluates if the result of the specified `expression` is between the results of -// `lowerBound` -// * (inclusive) and `upperBound` (inclusive). -// * -// * @param expression Determine if the result of this expression is between two bounds. -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// */ -// @JvmStatic -// internal fun between( -// expression: Expression, -// lowerBound: Expression, -// upperBound: Expression -// ): BooleanExpression = -// BooleanFunctionExpression("between", notImplemented, expression, lowerBound, upperBound) -// /** -// * Evaluates if the result of the specified `expression` is between the `lowerBound` -// (inclusive) -// * and `upperBound` (inclusive). -// * -// * @param expression Determine if the result of this expression is between two bounds. -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// */ -// @JvmStatic -// internal fun between( -// expression: Expression, -// lowerBound: Any, -// upperBound: Any -// ): BooleanExpression = -// between(expression, toExprOrConstant(lowerBound), toExprOrConstant(upperBound)) -// // TODO(search) SnippetOptions is internal until supported by the backend -// @Beta -// internal class SnippetOptions private constructor(options: InternalOptions) : -// AbstractOptions(options) { -// /** Creates a new, empty `SnippetOptions` object. */ -// constructor(rquery: String) : this(InternalOptions.EMPTY.with("query", encodeValue(rquery))) -// -// fun withMaxSnippetWidth(max: Int): SnippetOptions { -// return with("max_snippet_width", encodeValue(max)) -// } -// -// fun withMaxSnippets(max: Int): SnippetOptions { -// return with("max_snippets", encodeValue(max)) -// } -// -// fun withSeparator(separator: String): SnippetOptions { -// return with("separator", encodeValue(separator)) -// } -// -// internal override fun self(options: InternalOptions): SnippetOptions { -// return SnippetOptions(options) -// } -// } -// /** -// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search query -// in -// * `bold`. -// * -// * Note: This Expression can only be used within a `Search` stage. -// * -// * @param rquery Define the search query using the search DTS. -// */ -// @Beta -// fun snippet(rquery: String): Expression = -// FunctionExpression( -// "snippet", -// notImplemented, -// arrayOf(this, constant(rquery)), -// SnippetOptions(rquery).options -// ) -// -// /** -// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search query -// in -// * `bold`. -// * -// * Note: This Expression can only be used within a `Search` stage. -// * -// * @param options Define how the snippet is generated. -// * -// * TODO(search) implement snippet with SnippetOptions - out of scope for first release -// */ -// @Beta -// internal fun snippet(options: SnippetOptions): Expression { -// throw NotImplementedError() -// } -// -// /** -// * Evaluates if the result of this `expression` is between the `lowerBound` (inclusive) and -// * `upperBound` (inclusive). -// * -// * @example -// * ``` -// * // Evaluate if the 'tireWidth' is between 2.2 and 2.4 -// * field('tireWidth').between(constant(2.2), constant(2.4)) -// * -// * // This is functionally equivalent to -// * and( -// * field('tireWidth').greaterThanOrEqual(constant(2.2)), -// * field('tireWidth').lessThanOrEqual(constant(2.4))) -// * ``` -// * -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// * -// * TODO(search) publish between - out of scope for first release -// */ -// internal fun between(lowerBound: Expression, upperBound: Expression): BooleanExpression = -// Companion.between(this, lowerBound, upperBound) -// -// /** -// * Evaluates if the result of this `expression` is between the `lowerBound` (inclusive) and -// * `upperBound` (inclusive). -// * -// * @example -// * ``` -// * // Evaluate if the 'tireWidth' is between 2.2 and 2.4 -// * field('tireWidth').between(2.2, 2.4) -// * -// * // This is functionally equivalent to -// * and( -// * field('tireWidth').greaterThanOrEqual(2.2), -// * field('tireWidth').lessThanOrEqual(2.4)) -// * ``` -// * -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// * -// * TODO(search) publish between - out of scope for first release -// */ -// internal fun between(lowerBound: Any, upperBound: Any): BooleanExpression = -// Companion.between(this, lowerBound, upperBound) -// -// This block runs only if fieldValue is not null. -// This value is used if getField() returns null. -// /** -// * Perform a full-text search on this field. -// * -// * Note: This Expression can only be used within a `Search` stage. -// * -// * @param rquery Define the search query using the rquery DTS. -// */ -// @Beta internal fun matches(rquery: String): BooleanExpression = matches(this, rquery) -package com.google.firebase.firestore.pipeline; - - -/** Represents an expression that will be given the alias in the output document. */ - -@SuppressWarnings({"unchecked", "deprecation", "all"}) -public final class AliasedExpression extends com.google.firebase.firestore.pipeline.Selectable { - -AliasedExpression() { throw new RuntimeException("Stub!"); } - -public boolean equals(java.lang.Object other) { throw new RuntimeException("Stub!"); } - -public int hashCode() { throw new RuntimeException("Stub!"); } - -public java.lang.String getAlias() { throw new RuntimeException("Stub!"); } - -public com.google.firebase.firestore.pipeline.Expression getExpr() { throw new RuntimeException("Stub!"); } -} - - - -// File: BooleanExpression.java -// Copyright 2025 Google LLC -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file 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. -// Ensure this overload exists or is correctly placed -// /** -// * Perform a full-text search on the specified field. -// * -// * Note: This Expression can only be used within a `Search` stage. -// * -// * @example -// * ```kotlin -// * db.pipeline().collection("restaurants").search( -// * SearchStage(query = matches("menu", "waffles")) -// * ) -// * ``` -// * -// * @param fieldName Perform search on this field. -// * @param rquery Define the search query using the search DSL. -// */ -// // TODO(search) this is internal until supported by the backend -// @Beta -// @JvmStatic -// internal fun matches(fieldName: String, rquery: String): BooleanExpression = -// matches(field(fieldName), rquery) -// -// /** -// * Perform a full-text search on the specified field. -// * -// * Note: This Expression can only be used within a `Search` stage. -// * -// * @example -// * ```kotlin -// * db.pipeline().collection("restaurants").search( -// * SearchStage(query = matches(field("menu"), "waffles")) -// * ) -// * ``` -// * -// * @param field Perform search on this field. -// * @param rquery Define the search query using the search DSL. -// */ -// // TODO(search) this is internal until supported by the backend -// @Beta -// @JvmStatic -// internal fun matches(field: Field, rquery: String): BooleanExpression = -// BooleanFunctionExpression("matches", notImplemented, field, constant(rquery)) -// /** -// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search -// query -// * in `bold`. -// * -// * This Expression can only be used within a `Search` stage. -// * -// * @example -// * ```kotlin -// * db.pipeline().collection("restaurants").search( -// * SearchStage(query = documentMatches("waffles"), addFields = arrayOf(snippet("menu", -// "waffles").alias("snippet"))) -// * ) -// * ``` -// * -// * @param fieldName Search the specified field for matching terms. -// * @param rquery Define the search query using the search DSL. -// */ -// @Beta -// @JvmStatic -// fun snippet(fieldName: String, rquery: String): Expression = -// FunctionExpression("snippet", notImplemented, field(fieldName), constant(rquery)) -// /** -// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search -// query -// * in `bold`. -// * -// * This Expression can only be used within a `Search` stage. -// * -// * @param fieldName Search the specified field for matching terms. -// * @param options Define how the snippet is generated. -// */ -// // TODO(search) snippet with options is internal and unimplemented until supported by the -// // backend -// @Beta -// @JvmStatic -// internal fun snippet(fieldName: String, options: SnippetOptions): Expression { -// throw NotImplementedError("Not implemented") -// } -// /** -// * Evaluates if the value in the field specified by `fieldName` is between the evaluated -// values -// * for `lowerBound` (inclusive) and `upperBound` (inclusive). -// * -// * @param fieldName Determine if this field is between two bounds. -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// */ -// // TODO(search) between is internal and unimplemented until supported by the backend -// @JvmStatic -// internal fun between( -// fieldName: String, -// lowerBound: Expression, -// upperBound: Expression -// ): BooleanExpression = -// BooleanFunctionExpression("between", notImplemented, fieldName, lowerBound, upperBound) -// /** -// * Evaluates if the value in the field specified by `fieldName` is between the values for -// * `lowerBound` (inclusive) and `upperBound` (inclusive). -// * -// * @param fieldName Determine if this field is between two bounds. -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// */ -// @JvmStatic -// internal fun between(fieldName: String, lowerBound: Any, upperBound: Any): -// BooleanExpression = -// between(fieldName, toExprOrConstant(lowerBound), toExprOrConstant(upperBound)) -// /** -// * Evaluates if the result of the specified `expression` is between the results of -// `lowerBound` -// * (inclusive) and `upperBound` (inclusive). -// * -// * @param expression Determine if the result of this expression is between two bounds. -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// */ -// @JvmStatic -// internal fun between( -// expression: Expression, -// lowerBound: Expression, -// upperBound: Expression -// ): BooleanExpression = -// BooleanFunctionExpression("between", notImplemented, expression, lowerBound, upperBound) -// /** -// * Evaluates if the result of the specified `expression` is between the `lowerBound` -// (inclusive) -// * and `upperBound` (inclusive). -// * -// * @param expression Determine if the result of this expression is between two bounds. -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// */ -// @JvmStatic -// internal fun between( -// expression: Expression, -// lowerBound: Any, -// upperBound: Any -// ): BooleanExpression = -// between(expression, toExprOrConstant(lowerBound), toExprOrConstant(upperBound)) -// // TODO(search) SnippetOptions is internal until supported by the backend -// @Beta -// internal class SnippetOptions private constructor(options: InternalOptions) : -// AbstractOptions(options) { -// /** Creates a new, empty `SnippetOptions` object. */ -// constructor(rquery: String) : this(InternalOptions.EMPTY.with("query", encodeValue(rquery))) -// -// fun withMaxSnippetWidth(max: Int): SnippetOptions { -// return with("max_snippet_width", encodeValue(max)) -// } -// -// fun withMaxSnippets(max: Int): SnippetOptions { -// return with("max_snippets", encodeValue(max)) -// } -// -// fun withSeparator(separator: String): SnippetOptions { -// return with("separator", encodeValue(separator)) -// } -// -// internal override fun self(options: InternalOptions): SnippetOptions { -// return SnippetOptions(options) -// } -// } -// /** -// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search query -// in -// * `bold`. -// * -// * Note: This Expression can only be used within a `Search` stage. -// * -// * @param rquery Define the search query using the search DTS. -// */ -// @Beta -// fun snippet(rquery: String): Expression = -// FunctionExpression( -// "snippet", -// notImplemented, -// arrayOf(this, constant(rquery)), -// SnippetOptions(rquery).options -// ) -// -// /** -// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search query -// in -// * `bold`. -// * -// * Note: This Expression can only be used within a `Search` stage. -// * -// * @param options Define how the snippet is generated. -// * -// * TODO(search) implement snippet with SnippetOptions - out of scope for first release -// */ -// @Beta -// internal fun snippet(options: SnippetOptions): Expression { -// throw NotImplementedError() -// } -// -// /** -// * Evaluates if the result of this `expression` is between the `lowerBound` (inclusive) and -// * `upperBound` (inclusive). -// * -// * @example -// * ``` -// * // Evaluate if the 'tireWidth' is between 2.2 and 2.4 -// * field('tireWidth').between(constant(2.2), constant(2.4)) -// * -// * // This is functionally equivalent to -// * and( -// * field('tireWidth').greaterThanOrEqual(constant(2.2)), -// * field('tireWidth').lessThanOrEqual(constant(2.4))) -// * ``` -// * -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// * -// * TODO(search) publish between - out of scope for first release -// */ -// internal fun between(lowerBound: Expression, upperBound: Expression): BooleanExpression = -// Companion.between(this, lowerBound, upperBound) -// -// /** -// * Evaluates if the result of this `expression` is between the `lowerBound` (inclusive) and -// * `upperBound` (inclusive). -// * -// * @example -// * ``` -// * // Evaluate if the 'tireWidth' is between 2.2 and 2.4 -// * field('tireWidth').between(2.2, 2.4) -// * -// * // This is functionally equivalent to -// * and( -// * field('tireWidth').greaterThanOrEqual(2.2), -// * field('tireWidth').lessThanOrEqual(2.4)) -// * ``` -// * -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// * -// * TODO(search) publish between - out of scope for first release -// */ -// internal fun between(lowerBound: Any, upperBound: Any): BooleanExpression = -// Companion.between(this, lowerBound, upperBound) -// -// This block runs only if fieldValue is not null. -// This value is used if getField() returns null. -// /** -// * Perform a full-text search on this field. -// * -// * Note: This Expression can only be used within a `Search` stage. -// * -// * @param rquery Define the search query using the rquery DTS. -// */ -// @Beta internal fun matches(rquery: String): BooleanExpression = matches(this, rquery) -package com.google.firebase.firestore.pipeline; - - -/** A class that represents a filter condition. */ - -@SuppressWarnings({"unchecked", "deprecation", "all"}) -public abstract class BooleanExpression extends com.google.firebase.firestore.pipeline.Expression { - -/** A class that represents a filter condition. */ - -public BooleanExpression() { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that counts the number of stage inputs where the this boolean expression - * evaluates to true. - * - * @return A new [AggregateFunction] representing the count aggregation. - */ - -public final com.google.firebase.firestore.pipeline.AggregateFunction countIf() { throw new RuntimeException("Stub!"); } - -/** - * Creates a conditional expression that evaluates to a [thenExpr] expression if this condition is - * true or an [elseExpr] expression if the condition is false. - * - * @param thenExpr The expression to evaluate if the condition is true. - * @param elseExpr The expression to evaluate if the condition is false. - * @return A new [Expression] representing the conditional operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression conditional(com.google.firebase.firestore.pipeline.Expression thenExpr, com.google.firebase.firestore.pipeline.Expression elseExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates a conditional expression that evaluates to a [thenValue] if this condition is true or - * an [elseValue] if the condition is false. - * - * @param thenValue Value if the condition is true. - * @param elseValue Value if the condition is false. - * @return A new [Expression] representing the conditional operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression conditional(java.lang.Object thenValue, java.lang.Object elseValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that negates this boolean expression. - * - * @return A new [BooleanExpression] representing the not operation. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression not() { throw new RuntimeException("Stub!"); } - -/** - * Creates a 'raw' boolean function expression. This is useful if the expression is available in - * the backend, but not yet in the current version of the SDK yet. - * - * ```kotlin - * // Create a raw boolean function call - * BooleanExpression.rawFunction("my_boolean_function", field("arg1"), constant(true)) - * ``` - * - * @param name The name of the raw function. - * @param expr The expressions to be passed as arguments to the function. - * @return A new [BooleanExpression] representing the raw function. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression rawFunction(java.lang.String name, com.google.firebase.firestore.pipeline.Expression... expr) { throw new RuntimeException("Stub!"); } - -public static final com.google.firebase.firestore.pipeline.BooleanExpression.Companion Companion; -static { Companion = null; } -@SuppressWarnings({"unchecked", "deprecation", "all"}) -public static final class Companion { - -Companion() { throw new RuntimeException("Stub!"); } - -/** - * Creates a 'raw' boolean function expression. This is useful if the expression is available in - * the backend, but not yet in the current version of the SDK yet. - * - * ```kotlin - * // Create a raw boolean function call - * BooleanExpression.rawFunction("my_boolean_function", field("arg1"), constant(true)) - * ``` - * - * @param name The name of the raw function. - * @param expr The expressions to be passed as arguments to the function. - * @return A new [BooleanExpression] representing the raw function. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression rawFunction(java.lang.String name, com.google.firebase.firestore.pipeline.Expression... expr) { throw new RuntimeException("Stub!"); } -} - -} - - - -// File: Expression.java -// Copyright 2025 Google LLC -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file 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. -// Ensure this overload exists or is correctly placed -// /** -// * Perform a full-text search on the specified field. -// * -// * Note: This Expression can only be used within a `Search` stage. -// * -// * @example -// * ```kotlin -// * db.pipeline().collection("restaurants").search( -// * SearchStage(query = matches("menu", "waffles")) -// * ) -// * ``` -// * -// * @param fieldName Perform search on this field. -// * @param rquery Define the search query using the search DSL. -// */ -// // TODO(search) this is internal until supported by the backend -// @Beta -// @JvmStatic -// internal fun matches(fieldName: String, rquery: String): BooleanExpression = -// matches(field(fieldName), rquery) -// -// /** -// * Perform a full-text search on the specified field. -// * -// * Note: This Expression can only be used within a `Search` stage. -// * -// * @example -// * ```kotlin -// * db.pipeline().collection("restaurants").search( -// * SearchStage(query = matches(field("menu"), "waffles")) -// * ) -// * ``` -// * -// * @param field Perform search on this field. -// * @param rquery Define the search query using the search DSL. -// */ -// // TODO(search) this is internal until supported by the backend -// @Beta -// @JvmStatic -// internal fun matches(field: Field, rquery: String): BooleanExpression = -// BooleanFunctionExpression("matches", notImplemented, field, constant(rquery)) -// /** -// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search -// query -// * in `bold`. -// * -// * This Expression can only be used within a `Search` stage. -// * -// * @example -// * ```kotlin -// * db.pipeline().collection("restaurants").search( -// * SearchStage(query = documentMatches("waffles"), addFields = arrayOf(snippet("menu", -// "waffles").alias("snippet"))) -// * ) -// * ``` -// * -// * @param fieldName Search the specified field for matching terms. -// * @param rquery Define the search query using the search DSL. -// */ -// @Beta -// @JvmStatic -// fun snippet(fieldName: String, rquery: String): Expression = -// FunctionExpression("snippet", notImplemented, field(fieldName), constant(rquery)) -// /** -// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search -// query -// * in `bold`. -// * -// * This Expression can only be used within a `Search` stage. -// * -// * @param fieldName Search the specified field for matching terms. -// * @param options Define how the snippet is generated. -// */ -// // TODO(search) snippet with options is internal and unimplemented until supported by the -// // backend -// @Beta -// @JvmStatic -// internal fun snippet(fieldName: String, options: SnippetOptions): Expression { -// throw NotImplementedError("Not implemented") -// } -// /** -// * Evaluates if the value in the field specified by `fieldName` is between the evaluated -// values -// * for `lowerBound` (inclusive) and `upperBound` (inclusive). -// * -// * @param fieldName Determine if this field is between two bounds. -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// */ -// // TODO(search) between is internal and unimplemented until supported by the backend -// @JvmStatic -// internal fun between( -// fieldName: String, -// lowerBound: Expression, -// upperBound: Expression -// ): BooleanExpression = -// BooleanFunctionExpression("between", notImplemented, fieldName, lowerBound, upperBound) -// /** -// * Evaluates if the value in the field specified by `fieldName` is between the values for -// * `lowerBound` (inclusive) and `upperBound` (inclusive). -// * -// * @param fieldName Determine if this field is between two bounds. -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// */ -// @JvmStatic -// internal fun between(fieldName: String, lowerBound: Any, upperBound: Any): -// BooleanExpression = -// between(fieldName, toExprOrConstant(lowerBound), toExprOrConstant(upperBound)) -// /** -// * Evaluates if the result of the specified `expression` is between the results of -// `lowerBound` -// * (inclusive) and `upperBound` (inclusive). -// * -// * @param expression Determine if the result of this expression is between two bounds. -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// */ -// @JvmStatic -// internal fun between( -// expression: Expression, -// lowerBound: Expression, -// upperBound: Expression -// ): BooleanExpression = -// BooleanFunctionExpression("between", notImplemented, expression, lowerBound, upperBound) -// /** -// * Evaluates if the result of the specified `expression` is between the `lowerBound` -// (inclusive) -// * and `upperBound` (inclusive). -// * -// * @param expression Determine if the result of this expression is between two bounds. -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// */ -// @JvmStatic -// internal fun between( -// expression: Expression, -// lowerBound: Any, -// upperBound: Any -// ): BooleanExpression = -// between(expression, toExprOrConstant(lowerBound), toExprOrConstant(upperBound)) -// // TODO(search) SnippetOptions is internal until supported by the backend -// @Beta -// internal class SnippetOptions private constructor(options: InternalOptions) : -// AbstractOptions(options) { -// /** Creates a new, empty `SnippetOptions` object. */ -// constructor(rquery: String) : this(InternalOptions.EMPTY.with("query", encodeValue(rquery))) -// -// fun withMaxSnippetWidth(max: Int): SnippetOptions { -// return with("max_snippet_width", encodeValue(max)) -// } -// -// fun withMaxSnippets(max: Int): SnippetOptions { -// return with("max_snippets", encodeValue(max)) -// } -// -// fun withSeparator(separator: String): SnippetOptions { -// return with("separator", encodeValue(separator)) -// } -// -// internal override fun self(options: InternalOptions): SnippetOptions { -// return SnippetOptions(options) -// } -// } -// /** -// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search query -// in -// * `bold`. -// * -// * Note: This Expression can only be used within a `Search` stage. -// * -// * @param rquery Define the search query using the search DTS. -// */ -// @Beta -// fun snippet(rquery: String): Expression = -// FunctionExpression( -// "snippet", -// notImplemented, -// arrayOf(this, constant(rquery)), -// SnippetOptions(rquery).options -// ) -// -// /** -// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search query -// in -// * `bold`. -// * -// * Note: This Expression can only be used within a `Search` stage. -// * -// * @param options Define how the snippet is generated. -// * -// * TODO(search) implement snippet with SnippetOptions - out of scope for first release -// */ -// @Beta -// internal fun snippet(options: SnippetOptions): Expression { -// throw NotImplementedError() -// } -// -// /** -// * Evaluates if the result of this `expression` is between the `lowerBound` (inclusive) and -// * `upperBound` (inclusive). -// * -// * @example -// * ``` -// * // Evaluate if the 'tireWidth' is between 2.2 and 2.4 -// * field('tireWidth').between(constant(2.2), constant(2.4)) -// * -// * // This is functionally equivalent to -// * and( -// * field('tireWidth').greaterThanOrEqual(constant(2.2)), -// * field('tireWidth').lessThanOrEqual(constant(2.4))) -// * ``` -// * -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// * -// * TODO(search) publish between - out of scope for first release -// */ -// internal fun between(lowerBound: Expression, upperBound: Expression): BooleanExpression = -// Companion.between(this, lowerBound, upperBound) -// -// /** -// * Evaluates if the result of this `expression` is between the `lowerBound` (inclusive) and -// * `upperBound` (inclusive). -// * -// * @example -// * ``` -// * // Evaluate if the 'tireWidth' is between 2.2 and 2.4 -// * field('tireWidth').between(2.2, 2.4) -// * -// * // This is functionally equivalent to -// * and( -// * field('tireWidth').greaterThanOrEqual(2.2), -// * field('tireWidth').lessThanOrEqual(2.4)) -// * ``` -// * -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// * -// * TODO(search) publish between - out of scope for first release -// */ -// internal fun between(lowerBound: Any, upperBound: Any): BooleanExpression = -// Companion.between(this, lowerBound, upperBound) -// -// This block runs only if fieldValue is not null. -// This value is used if getField() returns null. -// /** -// * Perform a full-text search on this field. -// * -// * Note: This Expression can only be used within a `Search` stage. -// * -// * @param rquery Define the search query using the rquery DTS. -// */ -// @Beta internal fun matches(rquery: String): BooleanExpression = matches(this, rquery) -package com.google.firebase.firestore.pipeline; - - -/** - * Represents an expression that can be evaluated to a value within the execution of a [Pipeline]. - * - * Expressions are the building blocks for creating complex queries and transformations in Firestore - * pipelines. They can represent: - * - * - **Field references:** Access values from document fields. - * - **Literals:** Represent constant values (strings, numbers, booleans). - * - **Function calls:** Apply functions to one or more expressions. - * - * The [Expression] class provides a fluent API for building expressions. You can chain together - * method calls to create complex expressions. - */ - -@SuppressWarnings({"unchecked", "deprecation", "all"}) -public abstract class Expression { - -Expression() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise AND operation with other expression. - * - * ```kotlin - * // Bitwise AND the value of the 'flags' field with the value of the 'mask' field. - * field("flags").bitAnd(field("mask")) - * ``` - * - * @param bitsOther An expression that returns bits when evaluated. - * @return A new [Expression] representing the bitwise AND operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression bitAnd(com.google.firebase.firestore.pipeline.Expression bitsOther) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise AND operation with a constant. - * - * ```kotlin - * // Bitwise AND the value of the 'flags' field with a constant mask. - * field("flags").bitAnd(byteArrayOf(0b00001111)) - * ``` - * - * @param bitsOther A constant byte array. - * @return A new [Expression] representing the bitwise AND operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression bitAnd(byte[] bitsOther) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise OR operation with other expression. - * - * ```kotlin - * // Bitwise OR the value of the 'flags' field with the value of the 'mask' field. - * field("flags").bitOr(field("mask")) - * ``` - * - * @param bitsOther An expression that returns bits when evaluated. - * @return A new [Expression] representing the bitwise OR operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression bitOr(com.google.firebase.firestore.pipeline.Expression bitsOther) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise OR operation with a constant. - * - * ```kotlin - * // Bitwise OR the value of the 'flags' field with a constant mask. - * field("flags").bitOr(byteArrayOf(0b00001111)) - * ``` - * - * @param bitsOther A constant byte array. - * @return A new [Expression] representing the bitwise OR operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression bitOr(byte[] bitsOther) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise XOR operation with an expression. - * - * ```kotlin - * // Bitwise XOR the value of the 'flags' field with the value of the 'mask' field. - * field("flags").bitXor(field("mask")) - * ``` - * - * @param bitsOther An expression that returns bits when evaluated. - * @return A new [Expression] representing the bitwise XOR operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression bitXor(com.google.firebase.firestore.pipeline.Expression bitsOther) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise XOR operation with a constant. - * - * ```kotlin - * // Bitwise XOR the value of the 'flags' field with a constant mask. - * field("flags").bitXor(byteArrayOf(0b00001111)) - * ``` - * - * @param bitsOther A constant byte array. - * @return A new [Expression] representing the bitwise XOR operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression bitXor(byte[] bitsOther) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise NOT operation to this expression. - * - * ```kotlin - * // Bitwise NOT the value of the 'flags' field. - * field("flags").bitNot() - * ``` - * - * @return A new [Expression] representing the bitwise NOT operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression bitNot() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise left shift operation with an expression. - * - * ```kotlin - * // Left shift the value of the 'bits' field by the value of the 'shift' field. - * field("bits").bitLeftShift(field("shift")) - * ``` - * - * @param numberExpr The number of bits to shift. - * @return A new [Expression] representing the bitwise left shift operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression bitLeftShift(com.google.firebase.firestore.pipeline.Expression numberExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise left shift operation with a constant. - * - * ```kotlin - * // Left shift the value of the 'bits' field by 2. - * field("bits").bitLeftShift(2) - * ``` - * - * @param number The number of bits to shift. - * @return A new [Expression] representing the bitwise left shift operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression bitLeftShift(int number) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise right shift operation with an expression. - * - * ```kotlin - * // Right shift the value of the 'bits' field by the value of the 'shift' field. - * field("bits").bitRightShift(field("shift")) - * ``` - * - * @param numberExpr The number of bits to shift. - * @return A new [Expression] representing the bitwise right shift operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression bitRightShift(com.google.firebase.firestore.pipeline.Expression numberExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise right shift operation with a constant. - * - * ```kotlin - * // Right shift the value of the 'bits' field by 2. - * field("bits").bitRightShift(2) - * ``` - * - * @param number The number of bits to shift. - * @return A new [Expression] representing the bitwise right shift operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression bitRightShift(int number) { throw new RuntimeException("Stub!"); } - -/** - * Assigns an alias to this expression. - * - * Aliases are useful for renaming fields in the output of a stage or for giving meaningful names - * to calculated values. - * - * @param alias The alias to assign to this expression. - * @return A [AliasedExpression] that wraps this expression and associates it with the provided - * alias. - */ - -public com.google.firebase.firestore.pipeline.AliasedExpression alias(java.lang.String alias) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the document ID from this path expression. - * - * ```kotlin - * // Get the document ID from the 'path' field - * field("path").documentId() - * ``` - * - * @return A new [Expression] representing the documentId operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression documentId() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the parent document reference of this document reference - * expression. - * - * ```kotlin - * // Get the parent document reference of the 'path' field. - * field("path").parent() - * ``` - * - * @return A new [Expression] representing the parent operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression parent() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the collection ID from this path expression. - * - * ```kotlin - * // Get the collection ID from the 'path' field - * field("path").collectionId() - * ``` - * - * @return A new [Expression] representing the collectionId operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression collectionId() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the absolute value of this expression. - * - * ```kotlin - * // Get the absolute value of the 'change' field. - * field("change").abs() - * ``` - * - * @return A new [Expression] representing the numeric result of the absolute value operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression abs() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns Euler's number e raised to the power of this expression. - * - * ```kotlin - * // Compute e to the power of the 'value' field. - * field("value").exp() - * ``` - * - * @return A new [Expression] representing the numeric result of the exponentiation. - */ - -public final com.google.firebase.firestore.pipeline.Expression exp() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that adds this numeric expression to another numeric expression. - * - * ```kotlin - * // Add the value of the 'quantity' field and the 'reserve' field. - * field("quantity").add(field("reserve")) - * ``` - * - * @param second Numeric expression to add. - * @return A new [Expression] representing the addition operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression add(com.google.firebase.firestore.pipeline.Expression second) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that adds this numeric expression to a constants. - * - * ```kotlin - * // Add 5 to the value of the 'quantity' field. - * field("quantity").add(5) - * ``` - * - * @param second Constant to add. - * @return A new [Expression] representing the addition operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression add(java.lang.Number second) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that subtracts a constant from this numeric expression. - * - * ```kotlin - * // Subtract the 'discount' field from the 'price' field - * field("price").subtract(field("discount")) - * ``` - * - * @param subtrahend Numeric expression to subtract. - * @return A new [Expression] representing the subtract operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression subtract(com.google.firebase.firestore.pipeline.Expression subtrahend) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that subtracts a numeric expressions from this numeric expression. - * - * ```kotlin - * // Subtract 10 from the 'price' field. - * field("price").subtract(10) - * ``` - * - * @param subtrahend Constant to subtract. - * @return A new [Expression] representing the subtract operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression subtract(java.lang.Number subtrahend) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that multiplies this numeric expression with another numeric expression. - * - * ```kotlin - * // Multiply the 'quantity' field by the 'price' field - * field("quantity").multiply(field("price")) - * ``` - * - * @param second Numeric expression to multiply. - * @return A new [Expression] representing the multiplication operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression multiply(com.google.firebase.firestore.pipeline.Expression second) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that multiplies this numeric expression with a constant. - * - * ```kotlin - * // Multiply the 'quantity' field by 1.1. - * field("quantity").multiply(1.1) - * ``` - * - * @param second Constant to multiply. - * @return A new [Expression] representing the multiplication operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression multiply(java.lang.Number second) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that divides this numeric expression by another numeric expression. - * - * ```kotlin - * // Divide the 'total' field by the 'count' field - * field("total").divide(field("count")) - * ``` - * - * @param divisor Numeric expression to divide this numeric expression by. - * @return A new [Expression] representing the division operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression divide(com.google.firebase.firestore.pipeline.Expression divisor) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that divides this numeric expression by a constant. - * - * ```kotlin - * // Divide the 'value' field by 10 - * field("value").divide(10) - * ``` - * - * @param divisor Constant to divide this expression by. - * @return A new [Expression] representing the division operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression divide(java.lang.Number divisor) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the modulo (remainder) of dividing this numeric - * expressions by another numeric expression. - * - * ```kotlin - * // Calculate the remainder of dividing the 'value' field by the 'divisor' field - * field("value").mod(field("divisor")) - * ``` - * - * @param divisor The numeric expression to divide this expression by. - * @return A new [Expression] representing the modulo operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression mod(com.google.firebase.firestore.pipeline.Expression divisor) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the modulo (remainder) of dividing this numeric - * expressions by a constant. - * - * ```kotlin - * // Calculate the remainder of dividing the 'value' field by 3. - * field("value").mod(3) - * ``` - * - * @param divisor The constant to divide this expression by. - * @return A new [Expression] representing the modulo operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression mod(java.lang.Number divisor) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that rounds this numeric expression to nearest integer. - * - * ```kotlin - * // Round the value of the 'price' field. - * field("price").round() - * ``` - * - * Rounds away from zero in halfway cases. - * - * @return A new [Expression] representing an integer result from the round operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression round() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that rounds off this numeric expression to [decimalPlace] decimal places - * if [decimalPlace] is positive, rounds off digits to the left of the decimal point if - * [decimalPlace] is negative. Rounds away from zero in halfway cases. - * - * ```kotlin - * // Round the value of the 'price' field to 2 decimal places. - * field("price").roundToPrecision(2) - * ``` - * - * @param decimalPlace The number of decimal places to round. - * @return A new [Expression] representing the round operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression roundToPrecision(int decimalPlace) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that rounds off this numeric expression to [decimalPlace] decimal places - * if [decimalPlace] is positive, rounds off digits to the left of the decimal point if - * [decimalPlace] is negative. Rounds away from zero in halfway cases. - * - * ```kotlin - * // Round the value of the 'price' field to the number of decimal places specified in the - * // 'precision' field. - * field("price").roundToPrecision(field("precision")) - * ``` - * - * @param decimalPlace The number of decimal places to round. - * @return A new [Expression] representing the round operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression roundToPrecision(com.google.firebase.firestore.pipeline.Expression decimalPlace) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates this numeric expression to an integer. - * - * ```kotlin - * // Truncate the value of the 'rating' field. - * field("rating").trunc() - * ``` - * - * @return A new [Expression] representing the truncate operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression trunc() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates this numeric expression to [decimalPlace] decimal places - * if [decimalPlace] is positive, truncates digits to the left of the decimal point if - * [decimalPlace] is negative. - * - * ```kotlin - * // Truncate the value of the 'rating' field to 2 decimal places. - * field("rating").truncToPrecision(2) - * ``` - * - * @param decimalPlace The number of decimal places to truncate. - * @return A new [Expression] representing the truncate operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression truncToPrecision(int decimalPlace) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates this numeric expression to [decimalPlace] decimal places - * if [decimalPlace] is positive, truncates digits to the left of the decimal point if - * [decimalPlace] is negative. - * - * ```kotlin - * // Truncate the value of the 'rating' field to the number of decimal places specified in the - * // 'precision' field. - * field("rating").truncToPrecision(field("precision")) - * ``` - * - * @param decimalPlace The number of decimal places to truncate. - * @return A new [Expression] representing the truncate operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression truncToPrecision(com.google.firebase.firestore.pipeline.Expression decimalPlace) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the smallest integer that isn't less than this numeric - * expression. - * - * ```kotlin - * // Compute the ceiling of the 'price' field. - * field("price").ceil() - * ``` - * - * @return A new [Expression] representing an integer result from the ceil operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression ceil() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the largest integer that is not greater than this numeric - * expression. - * - * ```kotlin - * // Compute the floor of the 'price' field. - * field("price").floor() - * ``` - * - * @return A new [Expression] representing an integer result from the floor operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression floor() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns this numeric expression raised to the power of the - * [exponent]. Returns infinity on overflow and zero on underflow. - * - * ```kotlin - * // Raise the value of the 'base' field to the power of 2. - * field("base").pow(2) - * ``` - * - * @param exponent The numeric power to raise this numeric expression. - * @return A new [Expression] representing a numeric result from raising this numeric expression - * to the power of [exponent]. - */ - -public final com.google.firebase.firestore.pipeline.Expression pow(java.lang.Number exponent) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns this numeric expression raised to the power of the - * [exponent]. Returns infinity on overflow and zero on underflow. - * - * ```kotlin - * // Raise the value of the 'base' field to the power of the 'exponent' field. - * field("base").pow(field("exponent")) - * ``` - * - * @param exponent The numeric power to raise this numeric expression. - * @return A new [Expression] representing a numeric result from raising this numeric expression - * to the power of [exponent]. - */ - -public final com.google.firebase.firestore.pipeline.Expression pow(com.google.firebase.firestore.pipeline.Expression exponent) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the square root of this numeric expression. - * - * ```kotlin - * // Compute the square root of the 'value' field. - * field("value").sqrt() - * ``` - * - * @return A new [Expression] representing the numeric result of the square root operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression sqrt() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the natural logarithm of this numeric expression. - * - * ```kotlin - * // compute the natural logarithm of the 'value' field. - * field("value").ln() - * ``` - * - * @return A new [Expression] representing the numeric result of the natural logarithm operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression ln() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the base-10 logarithm of this numeric expression. - * - * ```kotlin - * // compute the base-10 logarithm of the 'value' field. - * field("value").log10() - * ``` - * - * @return A new [Expression] representing the numeric result of the base-10 logarithm operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression log10() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if this expression, when evaluated, is equal to any of the - * provided [values]. - * - * ```kotlin - * // Check if the 'category' field is either "Electronics" or the value of the 'primaryType' field. - * field("category").equalAny(listOf("Electronics", field("primaryType"))) - * ``` - * - * @param values The values to check against. - * @return A new [BooleanExpression] representing the 'IN' comparison. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression equalAny(java.util.List values) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if this expression, when evaluated, is equal to any of the - * elements of [arrayExpression]. - * - * ```kotlin - * // Check if the 'category' field is in the 'availableCategories' array field. - * field("category").equalAny(field("availableCategories")) - * ``` - * - * @param arrayExpression An expression that evaluates to an array, whose elements to check for - * equality to the input. - * @return A new [BooleanExpression] representing the 'IN' comparison. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression equalAny(com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if this expression, when evaluated, is not equal to all the - * provided [values]. - * - * ```kotlin - * // Check if the 'status' field is neither "pending" nor the value of the 'rejectedStatus' field. - * field("status").notEqualAny(listOf("pending", field("rejectedStatus"))) - * ``` - * - * @param values The values to check against. - * @return A new [BooleanExpression] representing the 'NOT IN' comparison. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression notEqualAny(java.util.List values) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if this expression, when evaluated, is not equal to all the - * elements of [arrayExpression]. - * - * ```kotlin - * // Check if the 'status' field is not in the 'inactiveStatuses' array field. - * field("status").notEqualAny(field("inactiveStatuses")) - * ``` - * - * @param arrayExpression An expression that evaluates to an array, whose elements to check for - * equality to the input. - * @return A new [BooleanExpression] representing the 'NOT IN' comparison. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression notEqualAny(com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns true if the result of this expression is absent. Otherwise, - * returns false even if the value is null. - * - * ```kotlin - * // Check if the field `value` is absent. - * field("value").isAbsent() - * ``` - * - * @return A new [BooleanExpression] representing the isAbsent operation. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression isAbsent() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the length of a string, array, map, vector, or blob - * expression. - * - * ```kotlin - * // Get the length of the 'value' field where the value type can be any of a string, array, map, vector or blob. - * field("value").length() - * ``` - * - * @return A new [Expression] representing the length operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression length() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the character length of this string expression in UTF8. - * - * ```kotlin - * // Get the character length of the 'name' field in UTF-8. - * field("name").charLength() - * ``` - * - * @return A new [Expression] representing the charLength operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression charLength() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the length of a string in UTF-8 bytes, or just the length - * of a Blob. - * - * ```kotlin - * // Calculate the length of the 'myString' field in bytes. - * field("myString").byteLength() - * ``` - * - * @return A new [Expression] representing the length of the string in bytes. - */ - -public final com.google.firebase.firestore.pipeline.Expression byteLength() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that performs a case-sensitive wildcard string comparison. - * - * ```kotlin - * // Check if the 'title' field contains the string "guide" - * field("title").like("%guide%") - * ``` - * - * @param pattern The pattern to search for. You can use "%" as a wildcard character. - * @return A new [BooleanExpression] representing the like operation. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression like(com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a string indicating the type of the value this expression - * evaluates to. - * - * ```kotlin - * // Get the type of the 'value' field. - * field("value").type() - * ``` - * - * @return A new [Expression] representing the type operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression type() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if the result of this expression is of the given type. - * - * Supported values for `type` are: "null", "array", "boolean", "bytes", "timestamp", "geo_point", - * "number", "int32", "int64", "float64", "decimal128", "map", "reference", "string", "vector", - * "max_key", "min_key", "object_id", "regex", and "request_timestamp". - * - * ```kotlin - * // Check if the 'age' field is an integer - * field("age").isType("int64") - * ``` - * - * @param type The type to check for. - * @return A new [BooleanExpression] that evaluates to true if the expression's result is of the - * given type, false otherwise. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression isType(java.lang.String type) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that splits this string or blob expression by a delimiter. - * - * ```kotlin - * // Split the 'tags' field by a comma - * field("tags").split(field("delimiter")) - * ``` - * - * @param delimiter The delimiter to split by. - * @return A new [Expression] that evaluates to an array of segments. - */ - -public final com.google.firebase.firestore.pipeline.Expression split(com.google.firebase.firestore.pipeline.Expression delimiter) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that splits this string or blob expression by a string delimiter. - * - * ```kotlin - * // Split the 'tags' field by a comma - * field("tags").split(",") - * ``` - * - * @param delimiter The string delimiter to split by. - * @return A new [Expression] that evaluates to an array of segments. - */ - -public final com.google.firebase.firestore.pipeline.Expression split(java.lang.String delimiter) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that splits this blob expression by a blob delimiter. - * - * ```kotlin - * // Split the 'data' field by a delimiter - * field("data").split(Blob.fromBytes(byteArrayOf(0x0a))) - * ``` - * - * @param delimiter The blob delimiter to split by. - * @return A new [Expression] that evaluates to an array of segments. - */ - -public final com.google.firebase.firestore.pipeline.Expression split(com.google.firebase.firestore.Blob delimiter) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that joins the elements of an array into a string. - * - * ```kotlin - * // Join the elements of the 'tags' field with a comma and space. - * field("tags").join(", ") - * ``` - * - * @param delimiter The string to use as a delimiter. - * @return A new [Expression] representing the join operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression join(java.lang.String delimiter) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that joins the elements of an array into a string. - * - * ```kotlin - * // Join the elements of the 'tags' field with the delimiter from the 'separator' field. - * field("tags").join(field("separator")) - * ``` - * - * @param delimiterExpression The expression that evaluates to the delimiter string. - * @return A new [Expression] representing the join operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression join(com.google.firebase.firestore.pipeline.Expression delimiterExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that performs a case-sensitive wildcard string comparison. - * - * ```kotlin - * // Check if the 'title' field contains the string "guide" - * field("title").like("%guide%") - * ``` - * - * @param pattern The pattern to search for. You can use "%" as a wildcard character. - * @return A new [BooleanExpression] representing the like operation. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression like(java.lang.String pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if this string expression contains a specified regular - * expression as a substring. - * - * ```kotlin - * // Check if the 'description' field contains "example" (case-insensitive) - * field("description").regexContains("(?i)example") - * ``` - * - * @param pattern The regular expression to use for the search. - * @return A new [BooleanExpression] representing the contains regular expression comparison. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression regexContains(com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if this string expression contains a specified regular - * expression as a substring. - * - * ```kotlin - * // Check if the 'description' field contains "example" (case-insensitive) - * field("description").regexContains("(?i)example") - * ``` - * - * @param pattern The regular expression to use for the search. - * @return A new [BooleanExpression] representing the contains regular expression comparison. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression regexContains(java.lang.String pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if this string expression matches a specified regular - * expression. - * - * ```kotlin - * // Check if the 'email' field matches a valid email pattern - * field("email").regexMatch("[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}") - * ``` - * - * @param pattern The regular expression to use for the match. - * @return A new [BooleanExpression] representing the regular expression match comparison. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression regexMatch(com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if this string expression matches a specified regular - * expression. - * - * ```kotlin - * // Check if the 'email' field matches a valid email pattern - * field("email").regexMatch("[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}") - * ``` - * - * @param pattern The regular expression to use for the match. - * @return A new [BooleanExpression] representing the regular expression match comparison. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression regexMatch(java.lang.String pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the largest value between multiple input expressions or - * literal values. Based on Firestore's value type ordering. - * - * ```kotlin - * // Returns the larger value between the 'timestamp' field and the current timestamp. - * field("timestamp").logicalMaximum(currentTimestamp()) - * ``` - * - * @param others Expressions or literals. - * @return A new [Expression] representing the logical maximum operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression logicalMaximum(com.google.firebase.firestore.pipeline.Expression... others) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the largest value between multiple input expressions or - * literal values. Based on Firestore's value type ordering. - * - * ```kotlin - * // Returns the larger value between the 'timestamp' field and the current timestamp. - * field("timestamp").logicalMaximum(currentTimestamp()) - * ``` - * - * @param others Expressions or literals. - * @return A new [Expression] representing the logical maximum operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression logicalMaximum(java.lang.Object... others) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the smallest value between multiple input expressions or - * literal values. Based on Firestore's value type ordering. - * - * ```kotlin - * // Returns the smaller value between the 'timestamp' field and the current timestamp. - * field("timestamp").logicalMinimum(currentTimestamp()) - * ``` - * - * @param others Expressions or literals. - * @return A new [Expression] representing the logical minimum operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression logicalMinimum(com.google.firebase.firestore.pipeline.Expression... others) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the smallest value between multiple input expressions or - * literal values. Based on Firestore's value type ordering. - * - * ```kotlin - * // Returns the smaller value between the 'timestamp' field and the current timestamp. - * field("timestamp").logicalMinimum(currentTimestamp()) - * ``` - * - * @param others Expressions or literals. - * @return A new [Expression] representing the logical minimum operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression logicalMinimum(java.lang.Object... others) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that reverses this string expression. - * - * ```kotlin - * // Reverse the value of the 'myString' field. - * field("myString").reverse() - * ``` - * - * @return A new [Expression] representing the reversed string. - */ - -public final com.google.firebase.firestore.pipeline.Expression reverse() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if this string expression contains a specified substring. - * - * ```kotlin - * // Check if the 'description' field contains the value of the 'keyword' field. - * field("description").stringContains(field("keyword")) - * ``` - * - * @param substring The expression representing the substring to search for. - * @return A new [BooleanExpression] representing the contains comparison. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression stringContains(com.google.firebase.firestore.pipeline.Expression substring) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if this string expression contains a specified substring. - * - * ```kotlin - * // Check if the 'description' field contains "example". - * field("description").stringContains("example") - * ``` - * - * @param substring The substring to search for. - * @return A new [BooleanExpression] representing the contains comparison. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression stringContains(java.lang.String substring) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if this string expression starts with a given [prefix]. - * - * ```kotlin - * // Check if the 'fullName' field starts with the value of the 'firstName' field - * field("fullName").startsWith(field("firstName")) - * ``` - * - * @param prefix The prefix string expression to check for. - * @return A new [BooleanExpression] representing the 'starts with' comparison. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression startsWith(com.google.firebase.firestore.pipeline.Expression prefix) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if this string expression starts with a given [prefix]. - * - * ```kotlin - * // Check if the 'name' field starts with "Mr." - * field("name").startsWith("Mr.") - * ``` - * - * @param prefix The prefix string to check for. - * @return A new [BooleanExpression] representing the 'starts with' comparison. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression startsWith(java.lang.String prefix) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if this string expression ends with a given [suffix]. - * - * ```kotlin - * // Check if the 'url' field ends with the value of the 'extension' field - * field("url").endsWith(field("extension")) - * ``` - * - * @param suffix The suffix string expression to check for. - * @return A new [BooleanExpression] representing the 'ends with' comparison. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression endsWith(com.google.firebase.firestore.pipeline.Expression suffix) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if this string expression ends with a given [suffix]. - * - * ```kotlin - * // Check if the 'filename' field ends with ".txt" - * field("filename").endsWith(".txt") - * ``` - * - * @param suffix The suffix string to check for. - * @return A new [BooleanExpression] representing the 'ends with' comparison. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression endsWith(java.lang.String suffix) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that performs a reverse operation on this string expression. - * - * ```kotlin - * // reverse the field "filename": "abc.txt" => "txt.cba" - * field("filename").stringReverse() - * ``` - * @return A new [Expression] representing the 'stringReverse' operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression stringReverse() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a substring of the given string. - * - * ```kotlin - * // Get a substring of the 'message' field starting at index 5 with length 10. - * field("message").substring(constant(5), constant(10)) - * ``` - * - * @param start The starting index of the substring. - * @param length The length of the substring. - * @return A new [Expression] representing the substring. - */ - -public final com.google.firebase.firestore.pipeline.Expression substring(com.google.firebase.firestore.pipeline.Expression start, com.google.firebase.firestore.pipeline.Expression length) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a substring of the given string. - * - * ```kotlin - * // Get a substring of the 'message' field starting at index 5 with length 10. - * field("message").substring(5, 10) - * ``` - * - * @param start The starting index of the substring. - * @param length The length of the substring. - * @return A new [Expression] representing the substring. - */ - -public final com.google.firebase.firestore.pipeline.Expression substring(int start, int length) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that converts this string expression to lowercase. - * - * ```kotlin - * // Convert the 'name' field to lowercase - * field("name").toLower() - * ``` - * - * @return A new [Expression] representing the lowercase string. - */ - -public final com.google.firebase.firestore.pipeline.Expression toLower() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that converts this string expression to uppercase. - * - * ```kotlin - * // Convert the 'title' field to uppercase - * field("title").toUpper() - * ``` - * - * @return A new [Expression] representing the uppercase string. - */ - -public final com.google.firebase.firestore.pipeline.Expression toUpper() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes leading and trailing whitespace from this string expression. - * - * ```kotlin - * // Trim whitespace from the 'userInput' field - * field("userInput").trim() - * ``` - * - * @return A new [Expression] representing the trimmed string. - */ - -public final com.google.firebase.firestore.pipeline.Expression trim() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes a set of leading and trailing values from this string - * expression. - * - * Note: The values to trim are treated as a **set**, not a substring. - * - * ```kotlin - * // Trim all '_' and '-' characters from the 'userInput' field - * field("userInput").trimValue("-_") - * ``` - * - * @param valueToTrim The set of values to trim from the string. - * @return A new [Expression] representing the trimmed string. - */ - -public final com.google.firebase.firestore.pipeline.Expression trimValue(java.lang.String valueToTrim) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes a set of leading and trailing values from this expression. - * The accepted types are string and blob. - * - * Note: The values to trim are treated as a **set**, not a substring. - * - * ```kotlin - * // Trim specified characters from the 'userInput' field - * field("userInput").trimValue(field("trimChars")) - * ``` - * - * @param valueToTrim The expression representing the set of values to trim from the string. - * @return A new [Expression] representing the trimmed string. - */ - -public final com.google.firebase.firestore.pipeline.Expression trimValue(com.google.firebase.firestore.pipeline.Expression valueToTrim) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes leading whitespace from this string expression. - * - * ```kotlin - * // Trim leading whitespace from the 'text' field. - * field("text").ltrim() - * ``` - * - * @return A new [Expression] representing the ltrim operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression ltrim() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes a set of leading values from this string expression. - * - * Note: The values to trim are treated as a **set**, not a substring. - * - * ```kotlin - * // Trim all leading '-' and '_' characters from the 'text' field. - * field("text").ltrimValue("-_") - * ``` - * - * @param valuesToTrim The string of characters to remove. - * @return A new [Expression] representing the ltrim operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression ltrimValue(java.lang.String valuesToTrim) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes a set of leading values from this string expression. - * - * Note: The values to trim are treated as a **set**, not a substring. - * - * ```kotlin - * // Trim leading characters defined by the 'chars' field from the 'text' field. - * field("text").ltrimValue(field("chars")) - * ``` - * - * @param valuesToTrim The expression representing the set of values to remove. - * @return A new [Expression] representing the ltrim operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression ltrimValue(com.google.firebase.firestore.pipeline.Expression valuesToTrim) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes trailing whitespace from this string expression. - * - * ```kotlin - * // Trim trailing whitespace from the 'text' field. - * field("text").rtrim() - * ``` - * - * @return A new [Expression] representing the rtrim operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression rtrim() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes a set of trailing characters from this string expression. - * - * Note: The values to trim are treated as a **set**, not a substring. - * - * ```kotlin - * // Trim all trailing '-' and '_' characters from the 'text' field. - * field("text").rtrimValue("-_") - * ``` - * - * @param valuesToTrim The set of values to remove. - * @return A new [Expression] representing the rtrim operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression rtrimValue(java.lang.String valuesToTrim) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes a set of trailing values from this string expression. - * - * Note: The values to trim are treated as a **set**, not a substring. - * - * ```kotlin - * // Trim trailing characters defined by the 'chars' field from the 'text' field. - * field("text").rtrimValue(field("chars")) - * ``` - * - * @param valuesToTrim The expression representing the set of values to remove. - * @return A new [Expression] representing the rtrim operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression rtrimValue(com.google.firebase.firestore.pipeline.Expression valuesToTrim) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that repeats this string expression a given number of times. - * - * ```kotlin - * // Repeat the 'name' field 3 times. - * field("name").stringRepeat(3) - * ``` - * - * @param count The number of times to repeat the string. - * @return A new [Expression] representing the stringRepeat operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression stringRepeat(int count) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that repeats this string expression a given number of times. - * - * ```kotlin - * // Repeat the 'name' field the number of times specified in the 'count' field. - * field("name").stringRepeat(field("count")) - * ``` - * - * @param count The expression representing the number of times to repeat the string. - * @return A new [Expression] representing the stringRepeat operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression stringRepeat(com.google.firebase.firestore.pipeline.Expression count) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that replaces all occurrences of a substring with another string. - * - * ```kotlin - * // Replace all occurrences of "cat" with "dog" in the 'text' field. - * field("text").stringReplaceAll("cat", "dog") - * ``` - * - * @param oldValue The substring to replace. - * @param newValue The replacement string. - * @return A new [Expression] representing the stringReplaceAll operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression stringReplaceAll(java.lang.String oldValue, java.lang.String newValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that replaces all occurrences of a substring with another string. - * - * ```kotlin - * // Replace all occurrences of the 'old' field with the 'new' field in 'text'. - * field("text").stringReplaceAll(field("old"), field("new")) - * ``` - * - * @param oldValue The expression representing the substring to replace. - * @param newValue The expression representing the replacement string. - * @return A new [Expression] representing the stringReplaceAll operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression stringReplaceAll(com.google.firebase.firestore.pipeline.Expression oldValue, com.google.firebase.firestore.pipeline.Expression newValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that replaces the first occurrence of a substring with another string. - * - * ```kotlin - * // Replace the first occurrence of "cat" with "dog" in the 'text' field. - * field("text").stringReplaceOne("cat", "dog") - * ``` - * - * @param oldValue The substring to replace. - * @param newValue The replacement string. - * @return A new [Expression] representing the stringReplaceOne operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression stringReplaceOne(java.lang.String oldValue, java.lang.String newValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that replaces the first occurrence of a substring with another string. - * - * ```kotlin - * // Replace the first occurrence of the 'old' field with the 'new' field in 'text'. - * field("text").stringReplaceOne(field("old"), field("new")) - * ``` - * - * @param oldValue The expression representing the substring to replace. - * @param newValue The expression representing the replacement string. - * @return A new [Expression] representing the stringReplaceOne operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression stringReplaceOne(com.google.firebase.firestore.pipeline.Expression oldValue, com.google.firebase.firestore.pipeline.Expression newValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the 0-based index of the first occurrence of the specified - * substring. - * - * ```kotlin - * // Get the index of "world" within the 'text' field. - * field("text").stringIndexOf("world") - * ``` - * - * @param substring The substring to search for. - * @return A new [Expression] representing the stringIndexOf operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression stringIndexOf(java.lang.String substring) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the 0-based index of the first occurrence of the specified - * substring. - * - * ```kotlin - * // Get the index of the 'search' field within the 'text' field. - * field("text").stringIndexOf(field("search")) - * ``` - * - * @param substring The expression representing the substring to search for. - * @return A new [Expression] representing the stringIndexOf operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression stringIndexOf(com.google.firebase.firestore.pipeline.Expression substring) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that concatenates string expressions together. - * - * ```kotlin - * // Combine the 'firstName', " ", and 'lastName' fields into a single string - * field("firstName").stringConcat(constant(" "), field("lastName")) - * ``` - * - * @param stringExpressions The string expressions to concatenate. - * @return A new [Expression] representing the concatenated string. - */ - -public final com.google.firebase.firestore.pipeline.Expression stringConcat(com.google.firebase.firestore.pipeline.Expression... stringExpressions) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that concatenates this string expression with string constants. - * - * ```kotlin - * // Combine the 'firstName', " ", and 'lastName' fields into a single string - * field("firstName").stringConcat(" ", "lastName") - * ``` - * - * @param strings The string constants to concatenate. - * @return A new [Expression] representing the concatenated string. - */ - -public final com.google.firebase.firestore.pipeline.Expression stringConcat(java.lang.String... strings) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that concatenates string expressions and string constants together. - * - * ```kotlin - * // Combine the 'firstName', " ", and 'lastName' fields into a single string - * field("firstName").stringConcat(" ", field("lastName")) - * ``` - * - * @param strings The string expressions or string constants to concatenate. - * @return A new [Expression] representing the concatenated string. - */ - -public final com.google.firebase.firestore.pipeline.Expression stringConcat(java.lang.Object... strings) { throw new RuntimeException("Stub!"); } - -/** - * Accesses a map (object) value using the provided [keyExpression]. - * - * ```kotlin - * // Get the value from the 'address' map field, using the key from the 'keyField' field - * field("address").mapGet(field("keyField")) - * ``` - * - * @param keyExpression The name of the key to remove from this map expression. - * @return A new [Expression] representing the value associated with the given key in the map. - */ - -public final com.google.firebase.firestore.pipeline.Expression mapGet(com.google.firebase.firestore.pipeline.Expression keyExpression) { throw new RuntimeException("Stub!"); } - -/** - * Accesses a map (object) value using the provided [key]. - * - * ```kotlin - * // Get the 'city' value from the 'address' map field - * field("address").mapGet("city") - * ``` - * - * @param key The key to access in the map. - * @return A new [Expression] representing the value associated with the given key in the map. - */ - -public final com.google.firebase.firestore.pipeline.Expression mapGet(java.lang.String key) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that merges multiple maps into a single map. If multiple maps have the - * same key, the later value is used. - * - * ```kotlin - * // Merges the map in the settings field with, a map literal, and a map in - * // that is conditionally returned by another expression - * field("settings").mapMerge( - * map(mapOf("enabled" to true)), - * conditional( - * field("isAdmin").equal(true), - * map(mapOf("admin" to true)), - * map(emptyMap()) - * ) - * ) - * ``` - * - * @param mapExpr Map expression that will be merged. - * @param otherMaps Additional maps to merge. - * @return A new [Expression] representing the mapMerge operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression mapMerge(com.google.firebase.firestore.pipeline.Expression mapExpr, com.google.firebase.firestore.pipeline.Expression... otherMaps) { throw new RuntimeException("Stub!"); } - -/** - * Accesses a field/property of a document or Map using the provided [key]. - * - * @param key The string key to access. - * @return A new [Expression] representing the value of the field. - */ - -public final com.google.firebase.firestore.pipeline.Expression getField(java.lang.String key) { throw new RuntimeException("Stub!"); } - -/** - * Accesses a field/property of a document or Map using the provided [keyExpression]. - * - * @param keyExpression The expression evaluating to the key to access. - * @return A new [Expression] representing the value of the field. - */ - -public final com.google.firebase.firestore.pipeline.Expression getField(com.google.firebase.firestore.pipeline.Expression keyExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes a key from this map expression. - * - * ```kotlin - * // Removes the key 'baz' from the input map. - * map(mapOf("foo" to "bar", "baz" to true)).mapRemove(constant("baz")) - * ``` - * - * @param keyExpression The name of the key to remove from this map expression. - * @return A new [Expression] that evaluates to a modified map. - */ - -public final com.google.firebase.firestore.pipeline.Expression mapRemove(com.google.firebase.firestore.pipeline.Expression keyExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes a key from this map expression. - * - * ```kotlin - * // Removes the key 'baz' from the input map. - * map(mapOf("foo" to "bar", "baz" to true)).mapRemove("baz") - * ``` - * - * @param key The name of the key to remove from this map expression. - * @return A new [Expression] that evaluates to a modified map. - */ - -public final com.google.firebase.firestore.pipeline.Expression mapRemove(java.lang.String key) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a new map with the specified entries added or updated. - * - * - Only performs shallow updates to the map. - * - Setting a value to `null` will retain the key with a `null` value. To remove a key entirely, - * use `mapRemove`. - * - * ```kotlin - * // Set the 'category' key to the value of the 'newCategory' field. - * field("metadata").mapSet(field("keyField"), field("newCategory")) - * ``` - * - * @param key The key to set. - * @param value The value to set. - * @param moreKeyValues Additional key-value pairs to set. - * @return A new [Expression] representing the map with the entries set. - */ - -public final com.google.firebase.firestore.pipeline.Expression mapSet(com.google.firebase.firestore.pipeline.Expression key, com.google.firebase.firestore.pipeline.Expression value, com.google.firebase.firestore.pipeline.Expression... moreKeyValues) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a new map with the specified entries added or updated. - * - * ```kotlin - * // Set the 'category' key to "Electronics" and 'active' to true. - * field("metadata").mapSet("category", "Electronics", "active", true) - * ``` - * - * @param key The key to set. - * @param value The value to set. - * @param moreKeyValues Additional key-value pairs to set. - * @return A new [Expression] representing the map with the entries set. - */ - -public final com.google.firebase.firestore.pipeline.Expression mapSet(java.lang.String key, java.lang.Object value, java.lang.Object... moreKeyValues) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the keys of this map expression. - * - * While the backend generally preserves insertion order, relying on the order of the output array - * is not guaranteed and should be avoided. - * - * ```kotlin - * // Get the keys of the 'metadata' map field. - * field("metadata").mapKeys() - * ``` - * - * @return A new [Expression] representing the keys of the map. - */ - -public final com.google.firebase.firestore.pipeline.Expression mapKeys() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the values of this map expression. - * - * While the backend generally preserves insertion order, relying on the order of the output array - * is not guaranteed and should be avoided. - * - * ```kotlin - * // Get the values of the 'metadata' map field. - * field("metadata").mapValues() - * ``` - * - * @return A new [Expression] representing the values of the map. - */ - -public final com.google.firebase.firestore.pipeline.Expression mapValues() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the entries of this map expression as an array of maps, - * where each map contains a "k" property for the key and a "v" property for the value. - * - * While the backend generally preserves insertion order, relying on the order of the output array - * is not guaranteed and should be avoided. - * - * ```kotlin - * // Get the entries of the 'metadata' map field. - * field("metadata").mapEntries() - * ``` - * - * @return A new [Expression] representing the entries of the map. - */ - -public final com.google.firebase.firestore.pipeline.Expression mapEntries() { throw new RuntimeException("Stub!"); } - -/** - * Calculates the Cosine distance between this and another vector expressions. - * - * ```kotlin - * // Calculate the cosine distance between the 'userVector' field and the 'itemVector' field - * field("userVector").cosineDistance(field("itemVector")) - * ``` - * - * @param vector The other vector (represented as an Expression) to compare against. - * @return A new [Expression] representing the cosine distance between the two vectors. - */ - -public final com.google.firebase.firestore.pipeline.Expression cosineDistance(com.google.firebase.firestore.pipeline.Expression vector) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the Cosine distance between this vector expression and a vector literal. - * - * ```kotlin - * // Calculate the Cosine distance between the 'location' field and a target location - * field("location").cosineDistance(doubleArrayOf(37.7749, -122.4194)) - * ``` - * - * @param vector The other vector (as an array of doubles) to compare against. - * @return A new [Expression] representing the cosine distance between the two vectors. - */ - -public final com.google.firebase.firestore.pipeline.Expression cosineDistance(double[] vector) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the Cosine distance between this vector expression and a vector literal. - * - * ```kotlin - * // Calculate the Cosine distance between the 'location' field and a target location - * field("location").cosineDistance(VectorValue.from(listOf(37.7749, -122.4194))) - * ``` - * - * @param vector The other vector (represented as an [VectorValue]) to compare against. - * @return A new [Expression] representing the cosine distance between the two vectors. - */ - -public final com.google.firebase.firestore.pipeline.Expression cosineDistance(com.google.firebase.firestore.VectorValue vector) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the dot product distance between this and another vector expression. - * - * ```kotlin - * // Calculate the dot product between the 'userVector' field and the 'itemVector' field - * field("userVector").dotProduct(field("itemVector")) - * ``` - * - * @param vector The other vector (represented as an Expression) to compare against. - * @return A new [Expression] representing the dot product distance between the two vectors. - */ - -public final com.google.firebase.firestore.pipeline.Expression dotProduct(com.google.firebase.firestore.pipeline.Expression vector) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the dot product distance between this vector expression and a vector literal. - * - * ```kotlin - * // Calculate the dot product between the 'vector' field and a constant vector - * field("vector").dotProduct(doubleArrayOf(1.0, 2.0, 3.0)) - * ``` - * - * @param vector The other vector (as an array of doubles) to compare against. - * @return A new [Expression] representing the dot product distance between the two vectors. - */ - -public final com.google.firebase.firestore.pipeline.Expression dotProduct(double[] vector) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the dot product distance between this vector expression and a vector literal. - * - * ```kotlin - * // Calculate the dot product between the 'vector' field and a constant vector - * field("vector").dotProduct(VectorValue.from(listOf(1.0, 2.0, 3.0))) - * ``` - * - * @param vector The other vector (represented as an [VectorValue]) to compare against. - * @return A new [Expression] representing the dot product distance between the two vectors. - */ - -public final com.google.firebase.firestore.pipeline.Expression dotProduct(com.google.firebase.firestore.VectorValue vector) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the Euclidean distance between this and another vector expression. - * - * ```kotlin - * // Calculate the Euclidean distance between the 'userVector' field and the 'itemVector' field - * field("userVector").euclideanDistance(field("itemVector")) - * ``` - * - * @param vector The other vector (represented as an Expression) to compare against. - * @return A new [Expression] representing the Euclidean distance between the two vectors. - */ - -public final com.google.firebase.firestore.pipeline.Expression euclideanDistance(com.google.firebase.firestore.pipeline.Expression vector) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the Euclidean distance between this vector expression and a vector literal. - * - * ```kotlin - * // Calculate the Euclidean distance between the 'vector' field and a constant vector - * field("vector").euclideanDistance(doubleArrayOf(1.0, 2.0, 3.0)) - * ``` - * - * @param vector The other vector (as an array of doubles) to compare against. - * @return A new [Expression] representing the Euclidean distance between the two vectors. - */ - -public final com.google.firebase.firestore.pipeline.Expression euclideanDistance(double[] vector) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the Euclidean distance between this vector expression and a vector literal. - * - * ```kotlin - * // Calculate the Euclidean distance between the 'vector' field and a constant vector - * field("vector").euclideanDistance(VectorValue.from(listOf(1.0, 2.0, 3.0))) - * ``` - * - * @param vector The other vector (represented as an [VectorValue]) to compare against. - * @return A new [Expression] representing the Euclidean distance between the two vectors. - */ - -public final com.google.firebase.firestore.pipeline.Expression euclideanDistance(com.google.firebase.firestore.VectorValue vector) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the length (dimension) of a Firestore Vector. - * - * ```kotlin - * // Get the vector length (dimension) of the field 'embedding'. - * field("embedding").vectorLength() - * ``` - * - * @return A new [Expression] representing the length (dimension) of the vector. - */ - -public final com.google.firebase.firestore.pipeline.Expression vectorLength() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that interprets this expression as the number of microseconds since the - * Unix epoch (1970-01-01 00:00:00 UTC) and returns a timestamp. - * - * ```kotlin - * // Interpret the 'microseconds' field as microseconds since epoch. - * field("microseconds").unixMicrosToTimestamp() - * ``` - * - * @return A new [Expression] representing the timestamp. - */ - -public final com.google.firebase.firestore.pipeline.Expression unixMicrosToTimestamp() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that converts this timestamp expression to the number of microseconds - * since the Unix epoch (1970-01-01 00:00:00 UTC). - * - * ```kotlin - * // Convert the 'timestamp' field to microseconds since epoch. - * field("timestamp").timestampToUnixMicros() - * ``` - * - * @return A new [Expression] representing the number of microseconds since epoch. - */ - -public final com.google.firebase.firestore.pipeline.Expression timestampToUnixMicros() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that interprets this expression as the number of milliseconds since the - * Unix epoch (1970-01-01 00:00:00 UTC) and returns a timestamp. - * - * ```kotlin - * // Interpret the 'milliseconds' field as milliseconds since epoch. - * field("milliseconds").unixMillisToTimestamp() - * ``` - * - * @return A new [Expression] representing the timestamp. - */ - -public final com.google.firebase.firestore.pipeline.Expression unixMillisToTimestamp() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that converts this timestamp expression to the number of milliseconds - * since the Unix epoch (1970-01-01 00:00:00 UTC). - * - * ```kotlin - * // Convert the 'timestamp' field to milliseconds since epoch. - * field("timestamp").timestampToUnixMillis() - * ``` - * - * @return A new [Expression] representing the number of milliseconds since epoch. - */ - -public final com.google.firebase.firestore.pipeline.Expression timestampToUnixMillis() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that interprets this expression as the number of seconds since the Unix - * epoch (1970-01-01 00:00:00 UTC) and returns a timestamp. - * - * ```kotlin - * // Interpret the 'seconds' field as seconds since epoch. - * field("seconds").unixSecondsToTimestamp() - * ``` - * - * @return A new [Expression] representing the timestamp. - */ - -public final com.google.firebase.firestore.pipeline.Expression unixSecondsToTimestamp() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that converts this timestamp expression to the number of seconds since - * the Unix epoch (1970-01-01 00:00:00 UTC). - * - * ```kotlin - * // Convert the 'timestamp' field to seconds since epoch. - * field("timestamp").timestampToUnixSeconds() - * ``` - * - * @return A new [Expression] representing the number of seconds since epoch. - */ - -public final com.google.firebase.firestore.pipeline.Expression timestampToUnixSeconds() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that adds a specified amount of time to this timestamp expression. - * - * ```kotlin - * // Add some duration determined by field 'unit' and 'amount' to the 'timestamp' field. - * field("timestamp").timestampAdd(field("unit"), field("amount")) - * ``` - * - * @param unit The expression representing the unit of time to add. Valid units include - * "microsecond", "millisecond", "second", "minute", "hour" and "day". - * @param amount The expression representing the amount of time to add. - * @return A new [Expression] representing the resulting timestamp. - */ - -public final com.google.firebase.firestore.pipeline.Expression timestampAdd(com.google.firebase.firestore.pipeline.Expression unit, com.google.firebase.firestore.pipeline.Expression amount) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that adds a specified amount of time to this timestamp expression. - * - * ```kotlin - * // Add 1 day to the 'timestamp' field. - * field("timestamp").timestampAdd("day", 1) - * ``` - * - * @param unit The unit of time to add. Valid units include "microsecond", "millisecond", - * "second", "minute", "hour" and "day". - * @param amount The amount of time to add. - * @return A new [Expression] representing the resulting timestamp. - */ - -public final com.google.firebase.firestore.pipeline.Expression timestampAdd(java.lang.String unit, long amount) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates this timestamp expression to a specified granularity. - * - * ```kotlin - * // Truncate the 'createdAt' timestamp to the beginning of the day. - * field("createdAt").timestampTruncate("day") - * ``` - * - * @param granularity The granularity to truncate to. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @return A new [Expression] representing the truncated timestamp. - */ - -public final com.google.firebase.firestore.pipeline.Expression timestampTruncate(java.lang.String granularity) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates this timestamp expression to a specified granularity. - * - * ```kotlin - * // Truncate the 'createdAt' timestamp to the beginning of the day. - * field("createdAt").timestampTruncate(field("granularity")) - * ``` - * - * @param granularity The granularity expression to truncate to. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @return A new [Expression] representing the truncated timestamp. - */ - -public final com.google.firebase.firestore.pipeline.Expression timestampTruncate(com.google.firebase.firestore.pipeline.Expression granularity) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates this timestamp expression to a specified granularity in a - * given timezone. - * - * ```kotlin - * // Truncate the 'createdAt' timestamp to the beginning of the day in "America/Los_Angeles" - * // timezone. - * field("createdAt").timestampTruncateWithTimezone("day", "America/Los_Angeles") - * ``` - * - * @param granularity The granularity to truncate to. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone to use for truncation. Valid values are from the TZ database - * (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". - * @return A new [Expression] representing the truncated timestamp. - */ - -public final com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(java.lang.String granularity, java.lang.String timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates this timestamp expression to a specified granularity in a - * given timezone. - * - * ```kotlin - * // Truncate the 'createdAt' timestamp to the beginning of the day in "America/Los_Angeles" - * // timezone. - * field("createdAt").timestampTruncateWithTimezone(field("granularity"), "America/Los_Angeles") - * ``` - * - * @param granularity The granularity expression to truncate to. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone to use for truncation. Valid values are from the TZ database - * (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". - * @return A new [Expression] representing the truncated timestamp. - */ - -public final com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(com.google.firebase.firestore.pipeline.Expression granularity, java.lang.String timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates this timestamp expression to a specified granularity in a - * given timezone. - * - * ```kotlin - * // Truncate the 'createdAt' timestamp to the beginning of the day in timezone specified by the - * // 'tz' field. - * field("createdAt").timestampTruncateWithTimezone("day", field("tz")) - * ``` - * - * @param granularity The granularity to truncate to. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone expression to use for truncation. Valid values are from the TZ - * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". - * @return A new [Expression] representing the truncated timestamp. - */ - -public final com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(java.lang.String granularity, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates this timestamp expression to a specified granularity in a - * given timezone. - * - * ```kotlin - * // Truncate the 'createdAt' timestamp to the beginning of the day in timezone specified by the - * // 'tz' field. - * field("createdAt").timestampTruncateWithTimezone(field("granularity"), field("tz")) - * ``` - * - * @param granularity The granularity expression to truncate to. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone expression to use for truncation. Valid values are from the TZ - * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". - * @return A new [Expression] representing the truncated timestamp. - */ - -public final com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(com.google.firebase.firestore.pipeline.Expression granularity, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the difference between this timestamp and another timestamp. - * - * ```kotlin - * // Calculate the difference determined by fields 'startAt' and 'unit'. - * field("endAt").timestampDiff(field("startAt"), field("unit")) - * ``` - * - * @param start The starting timestamp expression. - * @param unit The unit of time for the difference. Valid values include "microsecond", - * "millisecond", "second", "minute", "hour" and "day". - * @return A new [Expression] representing the difference. - */ - -public final com.google.firebase.firestore.pipeline.Expression timestampDiff(com.google.firebase.firestore.pipeline.Expression start, com.google.firebase.firestore.pipeline.Expression unit) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the difference between this timestamp and another timestamp. - * - * ```kotlin - * // Calculate the difference in days between 'endAt' and 'startAt' fields. - * field("endAt").timestampDiff(field("startAt"), "day") - * ``` - * - * @param start The starting timestamp expression. - * @param unit The unit of time for the difference. Valid values include "microsecond", - * "millisecond", "second", "minute", "hour" and "day". - * @return A new [Expression] representing the difference. - */ - -public final com.google.firebase.firestore.pipeline.Expression timestampDiff(com.google.firebase.firestore.pipeline.Expression start, java.lang.String unit) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the difference between this timestamp and another timestamp. - * - * ```kotlin - * // Calculate the difference in days between 'endAt' and 'startAt' fields. - * field("endAt").timestampDiff("startAt", "day") - * ``` - * - * @param startFieldName The starting timestamp field name. - * @param unit The unit of time for the difference. Valid values include "microsecond", - * "millisecond", "second", "minute", "hour" and "day". - * @return A new [Expression] representing the difference. - */ - -public final com.google.firebase.firestore.pipeline.Expression timestampDiff(java.lang.String startFieldName, java.lang.String unit) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that extracts a specified part from this timestamp expression. - * - * ```kotlin - * // Extract the part specified by the field 'part' from 'timestamp'. - * field("timestamp").timestampExtract(field("part")) - * ``` - * - * @param part The part to extract. Valid values are "microsecond", "millisecond", "second", - * "minute", "hour", "dayofweek", "day", "dayofyear", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @return A new [Expression] representing the extracted part. - */ - -public final com.google.firebase.firestore.pipeline.Expression timestampExtract(com.google.firebase.firestore.pipeline.Expression part) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that extracts a specified part from this timestamp expression. - * - * ```kotlin - * // Extract the day from the timestamp in the 'timestamp' field. - * field("timestamp").timestampExtract("day") - * ``` - * - * @param part The part to extract. Valid values are "microsecond", "millisecond", "second", - * "minute", "hour", "dayofweek", "day", "dayofyear", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @return A new [Expression] representing the extracted part. - */ - -public final com.google.firebase.firestore.pipeline.Expression timestampExtract(java.lang.String part) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that extracts a specified part from this timestamp expression in a given - * timezone. - * - * ```kotlin - * // Extract the part specified by the field 'part' from 'timestamp' in timezone 'America/Los_Angeles'. - * field("timestamp").timestampExtractWithTimezone(field("part"), "America/Los_Angeles") - * ``` - * - * @param part The part to extract. Valid values are "microsecond", "millisecond", "second", - * "minute", "hour", "dayofweek", "day", "dayofyear", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone to use for extraction. Valid values are from the TZ database - * (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not specified. - * @return A new [Expression] representing the extracted part. - */ - -public final com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(com.google.firebase.firestore.pipeline.Expression part, java.lang.String timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that extracts a specified part from this timestamp expression in a given - * timezone. - * - * ```kotlin - * // Extract the day from the timestamp in the 'timestamp' field in timezone 'America/Los_Angeles'. - * field("timestamp").timestampExtractWithTimezone("day", "America/Los_Angeles") - * ``` - * - * @param part The part to extract. Valid values are "microsecond", "millisecond", "second", - * "minute", "hour", "dayofweek", "day", "dayofyear", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone to use for extraction. Valid values are from the TZ database - * (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not specified. - * @return A new [Expression] representing the extracted part. - */ - -public final com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(java.lang.String part, java.lang.String timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that extracts a specified part from this timestamp expression in a given - * timezone. - * - * ```kotlin - * // Extract the part specified by the field 'part' from 'timestamp' in timezone specified by - * the field 'tz'. - * field("timestamp").timestampExtractWithTimezone(field("part"), field("tz")) - * ``` - * - * @param part The part to extract. Valid values are "microsecond", "millisecond", "second", - * "minute", "hour", "dayofweek", "day", "dayofyear", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone expression to use for extraction. Valid values are from the TZ - * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not - * specified. - * @return A new [Expression] representing the extracted part. - */ - -public final com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(com.google.firebase.firestore.pipeline.Expression part, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that extracts a specified part from this timestamp expression in a given - * timezone. - * - * ```kotlin - * // Extract the day from the timestamp in the 'timestamp' field in timezone specified by - * the field 'tz'. - * field("timestamp").timestampExtractWithTimezone("day", field("tz")) - * ``` - * - * @param part The part to extract. Valid values are "microsecond", "millisecond", "second", - * "minute", "hour", "dayofweek", "day", "dayofyear", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone expression to use for extraction. Valid values are from the TZ - * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not - * specified. - * @return A new [Expression] representing the extracted part. - */ - -public final com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(java.lang.String part, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that subtracts a specified amount of time to this timestamp expression. - * - * ```kotlin - * // Subtract some duration determined by field 'unit' and 'amount' from the 'timestamp' field. - * field("timestamp").timestampSubtract(field("unit"), field("amount")) - * ``` - * - * @param unit The expression representing the unit of time to subtract. Valid units include - * "microsecond", "millisecond", "second", "minute", "hour" and "day". - * @param amount The expression representing the amount of time to subtract. - * @return A new [Expression] representing the resulting timestamp. - */ - -public final com.google.firebase.firestore.pipeline.Expression timestampSubtract(com.google.firebase.firestore.pipeline.Expression unit, com.google.firebase.firestore.pipeline.Expression amount) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that subtracts a specified amount of time to this timestamp expression. - * - * ```kotlin - * // Subtract 1 day from the 'timestamp' field. - * field("timestamp").timestampSubtract("day", 1) - * ``` - * - * @param unit The unit of time to subtract. Valid units include "microsecond", "millisecond", - * "second", "minute", "hour" and "day". - * @param amount The amount of time to subtract. - * @return A new [Expression] representing the resulting timestamp. - */ - -public final com.google.firebase.firestore.pipeline.Expression timestampSubtract(java.lang.String unit, long amount) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that concatenates this expression's value with others. The values must be - * all strings, all arrays, or all blobs. Types cannot be mixed. - * - * ```kotlin - * // Concatenate a field with another field. - * field("firstName").concat(field("lastName")) - * ``` - * - * @param second The second expression to concatenate. - * @param others Additional expressions to concatenate. - * @return A new [Expression] representing the concatenation. - */ - -public final com.google.firebase.firestore.pipeline.Expression concat(com.google.firebase.firestore.pipeline.Expression second, java.lang.Object... others) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that concatenates this expression's value with others. The values must be - * all strings, all arrays, or all blobs. Types cannot be mixed. - * - * ```kotlin - * // Concatenate a field with a literal string. - * field("firstName").concat("lastName") - * ``` - * - * @param second The second value to concatenate. - * @param others Additional values to concatenate. - * @return A new [Expression] representing the concatenation. - */ - -public final com.google.firebase.firestore.pipeline.Expression concat(java.lang.Object second, java.lang.Object... others) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that concatenates a field's array value with other arrays. - * - * ```kotlin - * // Combine the 'items' array with another array field. - * field("items").arrayConcat(field("otherItems")) - * ``` - * - * @param secondArray An expression that evaluates to array to concatenate. - * @param otherArrays Optional additional array expressions or array literals to concatenate. - * @return A new [Expression] representing the arrayConcat operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression arrayConcat(com.google.firebase.firestore.pipeline.Expression secondArray, java.lang.Object... otherArrays) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that concatenates a field's array value with other arrays. - * - * ```kotlin - * // Combine the 'items' array with a literal array. - * field("items").arrayConcat(listOf("a", "b")) - * ``` - * - * @param secondArray An array expression or array literal to concatenate. - * @param otherArrays Optional additional array expressions or array literals to concatenate. - * @return A new [Expression] representing the arrayConcat operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression arrayConcat(java.lang.Object secondArray, java.lang.Object... otherArrays) { throw new RuntimeException("Stub!"); } - -/** - * Reverses the order of elements in the array. - * - * ```kotlin - * // Reverse the value of the 'myArray' field. - * field("myArray").arrayReverse() - * ``` - * - * @return A new [Expression] representing the arrayReverse operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression arrayReverse() { throw new RuntimeException("Stub!"); } - -/** - * Filters this array expression based on a predicate. - * - * ```kotlin - * // Filter 'scores' array to include only values greater than 50 - * field("scores").arrayFilter("score", greaterThan(variable("score"), 50)) - * ``` - * - * @param alias The alias to use for the current element in the filter expression. - * @param filter The predicate boolean expression used to filter the elements. - * @return A new [Expression] representing the arrayFilter operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression arrayFilter(java.lang.String alias, com.google.firebase.firestore.pipeline.BooleanExpression filter) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a provided transformation to each element in an array. - * - * ```kotlin - * // Transform 'scores' array by multiplying each score by 10 - * field("scores").arrayTransform("score", multiply(variable("score"), 10)) - * ``` - * - * @param elementAlias The alias to use for the current element in the transform expression. - * @param transform The expression used to transform the elements. - * @return A new [Expression] representing the arrayTransform operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression arrayTransform(java.lang.String elementAlias, com.google.firebase.firestore.pipeline.Expression transform) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a provided transformation to each element in an array, - * providing the element's index to the transformation expression. - * - * ```kotlin - * // Transform 'scores' array by adding the index - * field("scores").arrayTransformWithIndex("score", "i", add(variable("score"), variable("i"))) - * ``` - * - * @param elementAlias The alias to use for the current element in the transform expression. - * @param indexAlias The alias to use for the current index. - * @param transform The expression used to transform the elements. - * @return A new [Expression] representing the arrayTransformWithIndex operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression arrayTransformWithIndex(java.lang.String elementAlias, java.lang.String indexAlias, com.google.firebase.firestore.pipeline.Expression transform) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a slice of this array expression to its end. - * - * ```kotlin - * // Get elements from the 'items' array starting from index 2 - * field("items").arraySliceToEnd(2) - * ``` - * - * @param offset The starting index. - * @return A new [Expression] representing the arraySliceToEnd operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression arraySliceToEnd(int offset) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a slice of this array expression to its end. - * - * ```kotlin - * // Get elements from the 'items' array starting from the value of the 'offset' field - * field("items").arraySliceToEnd(field("offset")) - * ``` - * - * @param offset The starting index. - * @return A new [Expression] representing the arraySliceToEnd operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression arraySliceToEnd(com.google.firebase.firestore.pipeline.Expression offset) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a slice of this array expression. - * - * ```kotlin - * // Get 5 elements from the 'items' array starting from index 2 - * field("items").arraySlice(2, 5) - * ``` - * - * @param offset The starting index. - * @param length The number of elements to return. - * @return A new [Expression] representing the arraySlice operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression arraySlice(int offset, int length) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a slice of this array expression. - * - * ```kotlin - * // Get elements from the 'items' array using expressions for offset and length - * field("items").arraySlice(field("offset"), field("length")) - * ``` - * - * @param offset The starting index. - * @param length The number of elements to return. - * @return A new [Expression] representing the arraySlice operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression arraySlice(com.google.firebase.firestore.pipeline.Expression offset, com.google.firebase.firestore.pipeline.Expression length) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the sum of the elements in this array expression. - * - * ```kotlin - * // Get the sum of elements in the 'scores' array. - * field("scores").arraySum() - * ``` - * - * @return A new [Expression] representing the sum of the array elements. - */ - -public final com.google.firebase.firestore.pipeline.Expression arraySum() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if array contains a specific [element]. - * - * ```kotlin - * // Check if the 'sizes' array contains the value from the 'selectedSize' field - * field("sizes").arrayContains(field("selectedSize")) - * ``` - * - * @param element The element to search for in the array. - * @return A new [BooleanExpression] representing the arrayContains operation. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression arrayContains(com.google.firebase.firestore.pipeline.Expression element) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if array contains a specific [element]. - * - * ```kotlin - * // Check if the 'colors' array contains "red" - * field("colors").arrayContains("red") - * ``` - * - * @param element The element to search for in the array. - * @return A new [BooleanExpression] representing the arrayContains operation. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression arrayContains(java.lang.Object element) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if array contains all the specified [values]. - * - * ```kotlin - * // Check if the 'tags' array contains both the value in field "tag1" and the literal value "tag2" - * field("tags").arrayContainsAll(listOf(field("tag1"), "tag2")) - * ``` - * - * @param values The elements to check for in the array. - * @return A new [BooleanExpression] representing the arrayContainsAll operation. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAll(java.util.List values) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if array contains all elements of [arrayExpression]. - * - * ```kotlin - * // Check if the 'tags' array contains both of the values from field "tag1" and the literal value "tag2" - * field("tags").arrayContainsAll(array(field("tag1"), "tag2")) - * ``` - * - * @param arrayExpression The elements to check for in the array. - * @return A new [BooleanExpression] representing the arrayContainsAll operation. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAll(com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if array contains any of the specified [values]. - * - * ```kotlin - * // Check if the 'categories' array contains either values from field "cate1" or "cate2" - * field("categories").arrayContainsAny(listOf(field("cate1"), field("cate2"))) - * ``` - * - * @param values The elements to check for in the array. - * @return A new [BooleanExpression] representing the arrayContainsAny operation. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAny(java.util.List values) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if array contains any elements of [arrayExpression]. - * - * ```kotlin - * // Check if the 'groups' array contains either the value from the 'userGroup' field - * // or the value "guest" - * field("groups").arrayContainsAny(array(field("userGroup"), "guest")) - * ``` - * - * @param arrayExpression The elements to check for in the array. - * @return A new [BooleanExpression] representing the arrayContainsAny operation. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAny(com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the length of an array expression. - * - * ```kotlin - * // Get the number of items in the 'cart' array - * field("cart").arrayLength() - * ``` - * - * @return A new [Expression] representing the length of the array. - */ - -public final com.google.firebase.firestore.pipeline.Expression arrayLength() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first element of an array expression. - * - * ```kotlin - * // Get the first element of the 'myArray' field. - * field("myArray").arrayFirst() - * ``` - * - * @return A new [Expression] representing the first element. - */ - -public final com.google.firebase.firestore.pipeline.Expression arrayFirst() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first N elements of an array expression. - * - * ```kotlin - * // Get the first 2 elements of the 'myArray' field. - * field("myArray").arrayFirstN(2) - * ``` - * - * @param n The number of elements to return. - * @return A new [Expression] representing the first N elements. - */ - -public final com.google.firebase.firestore.pipeline.Expression arrayFirstN(int n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first N elements of an array expression. - * - * ```kotlin - * // Get the first 2 elements of the 'myArray' field. - * field("myArray").arrayFirstN(2) - * ``` - * - * @param n The number of elements to return. - * @return A new [Expression] representing the first N elements. - */ - -public final com.google.firebase.firestore.pipeline.Expression arrayFirstN(com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the last element of an array expression. - * - * ```kotlin - * // Get the last element of the 'myArray' field. - * field("myArray").arrayLast() - * ``` - * - * @return A new [Expression] representing the last element. - */ - -public final com.google.firebase.firestore.pipeline.Expression arrayLast() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the last N elements of an array expression. - * - * ```kotlin - * // Get the last 2 elements of the 'myArray' field. - * field("myArray").arrayLastN(2) - * ``` - * - * @param n The number of elements to return. - * @return A new [Expression] representing the last N elements. - */ - -public final com.google.firebase.firestore.pipeline.Expression arrayLastN(int n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the last N elements of an array expression. - * - * ```kotlin - * // Get the last 2 elements of the 'myArray' field. - * field("myArray").arrayLastN(2) - * ``` - * - * @param n The number of elements to return. - * @return A new [Expression] representing the last N elements. - */ - -public final com.google.firebase.firestore.pipeline.Expression arrayLastN(com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the minimum value of an array expression. - * - * ```kotlin - * // Get the minimum value of the 'myArray' field. - * field("myArray").arrayMinimum() - * ``` - * - * @return A new [Expression] representing the minimum value. - */ - -public final com.google.firebase.firestore.pipeline.Expression arrayMinimum() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the maximum value of an array expression. - * - * ```kotlin - * // Get the maximum value of the 'myArray' field. - * field("myArray").arrayMaximum() - * ``` - * - * @return A new [Expression] representing the maximum value. - */ - -public final com.google.firebase.firestore.pipeline.Expression arrayMaximum() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first `n` smallest elements of the [array]. - * - * Note: Returns the n smallest non-null elements in the array, in ascending order. This does not - * use a stable sort, meaning the order of equivalent elements is undefined. - * - * ```kotlin - * // Get the 3 smallest elements of the 'myArray' field. - * field("myArray").arrayMinimumN(3) - * ``` - * - * @param n The number of elements to return. - * @return A new [Expression] representing the first `n` smallest elements. - */ - -public final com.google.firebase.firestore.pipeline.Expression arrayMinimumN(int n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first `n` smallest elements of the [array]. - * - * Note: Returns the n smallest non-null elements in the array, in ascending order. This does not - * use a stable sort, meaning the order of equivalent elements is undefined. - * - * ```kotlin - * // Get the n smallest elements of the 'myArray' field. - * field("myArray").arrayMinimumN(field("count")) - * ``` - * - * @param n An expression evaluating to the number of elements to return. - * @return A new [Expression] representing the first `n` smallest elements. - */ - -public final com.google.firebase.firestore.pipeline.Expression arrayMinimumN(com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first `n` largest elements of the [array]. - * - * Note: Returns the n largest non-null elements in the array, in descending order. This does not - * use a stable sort, meaning the order of equivalent elements is undefined. - * - * ```kotlin - * // Get the 3 largest elements of the 'myArray' field. - * field("myArray").arrayMaximumN(3) - * ``` - * - * @param n The number of elements to return. - * @return A new [Expression] representing the first `n` largest elements. - */ - -public final com.google.firebase.firestore.pipeline.Expression arrayMaximumN(int n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first `n` largest elements of the [array]. - * - * Note: Returns the n largest non-null elements in the array, in descending order. This does not - * use a stable sort, meaning the order of equivalent elements is undefined. - * - * ```kotlin - * // Get the n largest elements of the 'myArray' field. - * field("myArray").arrayMaximumN(field("count")) - * ``` - * - * @param n An expression evaluating to the number of elements to return. - * @return A new [Expression] representing the first `n` largest elements. - */ - -public final com.google.firebase.firestore.pipeline.Expression arrayMaximumN(com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first index where the specified [value] occurs in the - * [array]. - * - * ```kotlin - * // Get the first index of 'foo' in the 'tags' array field. - * field("tags").arrayIndexOf("foo") - * ``` - * - * @param value The value to search for. - * @return A new [Expression] representing the index of the value. - */ - -public final com.google.firebase.firestore.pipeline.Expression arrayIndexOf(java.lang.Object value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the last index where the specified [value] occurs in the - * [array]. - * - * ```kotlin - * // Get the last index of 'foo' in the 'tags' array field. - * field("tags").arrayLastIndexOf("foo") - * ``` - * - * @param value The value to search for. - * @return A new [Expression] representing the index of the value. - */ - -public final com.google.firebase.firestore.pipeline.Expression arrayLastIndexOf(java.lang.Object value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a list of all indices where the specified [value] occurs in - * the [array]. - * - * ```kotlin - * // Get all indices of 'foo' in the 'tags' array field. - * field("tags").arrayIndexOfAll("foo") - * ``` - * - * @param value The value to search for. - * @return A new [Expression] representing the list of indices. - */ - -public final com.google.firebase.firestore.pipeline.Expression arrayIndexOfAll(java.lang.Object value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that indexes into an array from the beginning or end and return the - * element. If the offset exceeds the array length, an error is returned. A negative offset, - * starts from the end. - * - * ```kotlin - * // Return the value in the tags field array at index specified by field 'favoriteTag'. - * field("tags").arrayGet(field("favoriteTag")) - * ``` - * - * @param offset An Expression evaluating to the index of the element to return. - * @return A new [Expression] representing the arrayOffset operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression arrayGet(com.google.firebase.firestore.pipeline.Expression offset) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that indexes into an array from the beginning or end and return the - * element. If the offset exceeds the array length, an error is returned. A negative offset, - * starts from the end. - * - * ```kotlin - * // Return the value in the 'tags' field array at index `1`. - * field("tags").arrayGet(1) - * ``` - * - * @param offset An Expression evaluating to the index of the element to return. - * @return A new [Expression] representing the arrayOffset operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression arrayGet(int offset) { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that counts the number of stage inputs with valid evaluations of the - * this expression. - * - * @return A new [AggregateFunction] representing the count aggregation. - */ - -public final com.google.firebase.firestore.pipeline.AggregateFunction count() { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that counts the number of distinct values of an expression across - * multiple stage inputs. - * - * @return A new [AggregateFunction] representing the count distinct aggregation. - */ - -public final com.google.firebase.firestore.pipeline.AggregateFunction countDistinct() { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that calculates the sum of this numeric expression across multiple stage - * inputs. - * - * @return A new [AggregateFunction] representing the sum aggregation. - */ - -public final com.google.firebase.firestore.pipeline.AggregateFunction sum() { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that calculates the average (mean) of this numeric expression across - * multiple stage inputs. - * - * @return A new [AggregateFunction] representing the average aggregation. - */ - -public final com.google.firebase.firestore.pipeline.AggregateFunction average() { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that finds the minimum value of this expression across multiple stage - * inputs. - * - * @return A new [AggregateFunction] representing the minimum aggregation. - */ - -public final com.google.firebase.firestore.pipeline.AggregateFunction minimum() { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that finds the maximum value of this expression across multiple stage - * inputs. - * - * @return A new [AggregateFunction] representing the maximum aggregation. - */ - -public final com.google.firebase.firestore.pipeline.AggregateFunction maximum() { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that finds the first value of this expression across multiple stage - * inputs. - * - * @return A new [AggregateFunction] representing the first aggregation. - */ - -public final com.google.firebase.firestore.pipeline.AggregateFunction first() { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that finds the last value of this expression across multiple stage - * inputs. - * - * @return A new [AggregateFunction] representing the last aggregation. - */ - -public final com.google.firebase.firestore.pipeline.AggregateFunction last() { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that collects all values of this expression across multiple stage inputs - * into an array. - * - * If the expression resolves to an absent value, it is converted to `null`. The order of elements - * in the output array is not stable and shouldn't be relied upon. - * - * @return A new [AggregateFunction] representing the array_agg aggregation. - */ - -public final com.google.firebase.firestore.pipeline.AggregateFunction arrayAgg() { throw new RuntimeException("Stub!"); } - -/** - * Creates an aggregation that collects all distinct values of this expression across multiple - * stage inputs into an array. - * - * If the expression resolves to an absent value, it is converted to `null`. The order of elements - * in the output array is not stable and shouldn't be relied upon. - * - * @return A new [AggregateFunction] representing the array_agg_distinct aggregation. - */ - -public final com.google.firebase.firestore.pipeline.AggregateFunction arrayAggDistinct() { throw new RuntimeException("Stub!"); } - -/** - * Create an [Ordering] that sorts documents in ascending order based on value of this expression - * - * @return A new [Ordering] object with ascending sort by this expression. - */ - -public final com.google.firebase.firestore.pipeline.Ordering ascending() { throw new RuntimeException("Stub!"); } - -/** - * Create an [Ordering] that sorts documents in descending order based on value of this expression - * - * @return A new [Ordering] object with descending sort by this expression. - */ - -public final com.google.firebase.firestore.pipeline.Ordering descending() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if this and [other] expression are equal. - * - * ```kotlin - * // Check if the 'age' field is equal to an expression - * field("age").equal(field("minAge").add(10)) - * ``` - * - * @param other The expression to compare to. - * @return A new [BooleanExpression] representing the equality comparison. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression equal(com.google.firebase.firestore.pipeline.Expression other) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if this expression is equal to a [value]. - * - * ```kotlin - * // Check if the 'age' field is equal to 21 - * field("age").equal(21) - * ``` - * - * @param value The value to compare to. - * @return A new [BooleanExpression] representing the equality comparison. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression equal(java.lang.Object value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if this expressions is not equal to the [other] expression. - * - * ```kotlin - * // Check if the 'status' field is not equal to the value of the 'otherStatus' field - * field("status").notEqual(field("otherStatus")) - * ``` - * - * @param other The expression to compare to. - * @return A new [BooleanExpression] representing the inequality comparison. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression notEqual(com.google.firebase.firestore.pipeline.Expression other) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if this expression is not equal to a [value]. - * - * ```kotlin - * // Check if the 'status' field is not equal to "completed" - * field("status").notEqual("completed") - * ``` - * - * @param value The value to compare to. - * @return A new [BooleanExpression] representing the inequality comparison. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression notEqual(java.lang.Object value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if this expression is greater than the [other] expression. - * - * ```kotlin - * // Check if the 'age' field is greater than the 'limit' field - * field("age").greaterThan(field("limit")) - * ``` - * - * @param other The expression to compare to. - * @return A new [BooleanExpression] representing the greater than comparison. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression greaterThan(com.google.firebase.firestore.pipeline.Expression other) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if this expression is greater than a [value]. - * - * ```kotlin - * // Check if the 'price' field is greater than 100 - * field("price").greaterThan(100) - * ``` - * - * @param value The value to compare to. - * @return A new [BooleanExpression] representing the greater than comparison. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression greaterThan(java.lang.Object value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if this expression is greater than or equal to the [other] - * expression. - * - * ```kotlin - * // Check if the 'quantity' field is greater than or equal to field 'requirement' plus 1 - * field("quantity").greaterThanOrEqual(field("requirement").add(1)) - * ``` - * - * @param other The expression to compare to. - * @return A new [BooleanExpression] representing the greater than or equal to comparison. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression greaterThanOrEqual(com.google.firebase.firestore.pipeline.Expression other) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if this expression is greater than or equal to a [value]. - * - * ```kotlin - * // Check if the 'score' field is greater than or equal to 80 - * field("score").greaterThanOrEqual(80) - * ``` - * - * @param value The value to compare to. - * @return A new [BooleanExpression] representing the greater than or equal to comparison. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression greaterThanOrEqual(java.lang.Object value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if this expression is less than the [other] expression. - * - * ```kotlin - * // Check if the 'age' field is less than 'limit' - * field("age").lessThan(field("limit")) - * ``` - * - * @param other The expression to compare to. - * @return A new [BooleanExpression] representing the less than comparison. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression lessThan(com.google.firebase.firestore.pipeline.Expression other) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if this expression is less than a value. - * - * ```kotlin - * // Check if the 'price' field is less than 50 - * field("price").lessThan(50) - * ``` - * - * @param value The value to compare to. - * @return A new [BooleanExpression] representing the less than comparison. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression lessThan(java.lang.Object value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if this expression is less than or equal to the [other] - * expression. - * - * ```kotlin - * // Check if the 'quantity' field is less than or equal to 20 - * field("quantity").lessThanOrEqual(constant(20)) - * ``` - * - * @param other The expression to compare to. - * @return A new [BooleanExpression] representing the less than or equal to comparison. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression lessThanOrEqual(com.google.firebase.firestore.pipeline.Expression other) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if this expression is less than or equal to a [value]. - * - * ```kotlin - * // Check if the 'score' field is less than or equal to 70 - * field("score").lessThanOrEqual(70) - * ``` - * - * @param value The value to compare to. - * @return A new [BooleanExpression] representing the less than or equal to comparison. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression lessThanOrEqual(java.lang.Object value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if this expression evaluates to a name of the field that - * exists. - * - * @return A new [Expression] representing the exists check. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression exists() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [catchExpr] argument if there is an error, else return - * the result of this expression. - * - * ```kotlin - * // Returns the first item in the title field arrays, or returns - * // the entire title field if the array is empty or the field is another type. - * arrayGet(field("title"), 0).ifError(field("title")) - * ``` - * - * @param catchExpr The catch expression that will be evaluated and returned if the this - * expression produces an error. - * @return A new [Expression] representing the ifError operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression ifError(com.google.firebase.firestore.pipeline.Expression catchExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [catchValue] argument if there is an error, else return - * the result of this expression. - * - * ```kotlin - * // Returns the first item in the title field arrays, or returns "Default Title" - * arrayGet(field("title"), 0).ifError("Default Title") - * ``` - * - * @param catchValue The value that will be returned if this expression produces an error. - * @return A new [Expression] representing the ifError operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression ifError(java.lang.Object catchValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [elseExpr] argument if this expression is absent, else - * return the result of this expression. - * - * ```kotlin - * // Returns the value of the optional field 'optional_field', or returns 'default_value' - * // if the field is absent. - * field("optional_field").ifAbsent("default_value") - * ``` - * - * @param elseExpr The expression that will be evaluated and returned if this expression is - * absent. - * @return A new [Expression] representing the ifAbsent operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression ifAbsent(com.google.firebase.firestore.pipeline.Expression elseExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [elseValue] argument if this expression is absent, else - * return the result of this expression. - * - * ```kotlin - * // Returns the value of the optional field 'optional_field', or returns 'default_value' - * // if the field is absent. - * field("optional_field").ifAbsent("default_value") - * ``` - * - * @param elseValue The value that will be returned if this expression is absent. - * @return A new [Expression] representing the ifAbsent operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression ifAbsent(java.lang.Object elseValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [elseExpression] argument if this expression evaluates - * to null, else return the result of this expression. - * - * This function provides a fallback for both absent and explicit null values. In contrast, - * [ifAbsent] only triggers for missing fields. - * - * ```kotlin - * // Returns the user's preferred name, or if that is null, returns their full name. - * field("preferredName").ifNull(field("fullName")) - * ``` - * - * @param elseExpression The expression that will be evaluated and returned if this expression is - * null. - * @return A new [Expression] representing the ifNull operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression ifNull(com.google.firebase.firestore.pipeline.Expression elseExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [elseValue] argument if this expression evaluates to - * null, else return the result of this expression. - * - * This function provides a fallback for both absent and explicit null values. In contrast, - * [ifAbsent] only triggers for missing fields. - * - * ```kotlin - * // Returns the user's display name, or returns "Anonymous" if the field is null. - * field("displayName").ifNull("Anonymous") - * ``` - * - * @param elseValue The value that will be returned if this expression evaluates to null. - * @return A new [Expression] representing the ifNull operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression ifNull(java.lang.Object elseValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first non-null, non-absent argument, without evaluating - * the rest of the arguments. When all arguments are null or absent, returns the last argument. - * - * ```kotlin - * // Returns the value of the first non-null, non-absent field among 'preferredName', 'fullName', - * // or the last argument if all previous fields are null. - * field("preferredName").coalesce(field("fullName"), "Anonymous") - * ``` - * - * @param replacement The fallback expression or value if the first one is null. - * @param others Optional additional expressions to check if previous ones are null. - * @return A new [Expression] representing the coalesce operation. - */ - -public final com.google.firebase.firestore.pipeline.Expression coalesce(java.lang.Object replacement, java.lang.Object... others) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if this expression produces an error. - * - * ```kotlin - * // Check if the result of a calculation is an error - * arrayContains(field("title"), 1).isError() - * ``` - * - * @return A new [BooleanExpression] representing the `isError` check. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression isError() { throw new RuntimeException("Stub!"); } - -/** - * Casts the expression to a [BooleanExpression]. - * - * @return A [BooleanExpression] representing the same expression. - */ - -public final com.google.firebase.firestore.pipeline.BooleanExpression asBoolean() { throw new RuntimeException("Stub!"); } - -/** - * Create a constant for a [String] value. - * - * ```kotlin - * // Create a constant with the value "hello" - * constant("hello") - * ``` - * - * @param value The [String] value. - * @return A new [Expression] constant instance. - */ - -public static final com.google.firebase.firestore.pipeline.Expression constant(java.lang.String value) { throw new RuntimeException("Stub!"); } - -/** - * Create a constant for a [Number] value. - * - * ```kotlin - * // Create a constant with the value 123 - * constant(123) - * ``` - * - * @param value The [Number] value. - * @return A new [Expression] constant instance. - */ - -public static final com.google.firebase.firestore.pipeline.Expression constant(java.lang.Number value) { throw new RuntimeException("Stub!"); } - -/** - * Create a constant for a [Date] value. - * - * ```kotlin - * // Create a constant with the current date - * constant(Date()) - * ``` - * - * @param value The [Date] value. - * @return A new [Expression] constant instance. - */ - -public static final com.google.firebase.firestore.pipeline.Expression constant(java.util.Date value) { throw new RuntimeException("Stub!"); } - -/** - * Create a constant for a [Timestamp] value. - * - * ```kotlin - * // Create a constant with the current timestamp - * constant(Timestamp.now()) - * ``` - * - * @param value The [Timestamp] value. - * @return A new [Expression] constant instance. - */ - -public static final com.google.firebase.firestore.pipeline.Expression constant(com.google.firebase.Timestamp value) { throw new RuntimeException("Stub!"); } - -/** - * Create a constant for a [Boolean] value. - * - * ```kotlin - * // Create a constant with the value true - * constant(true) - * ``` - * - * @param value The [Boolean] value. - * @return A new [BooleanExpression] constant instance. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression constant(boolean value) { throw new RuntimeException("Stub!"); } - -/** - * Create a constant for a [GeoPoint] value. - * - * ```kotlin - * // Create a constant with a GeoPoint - * constant(GeoPoint(37.7749, -122.4194)) - * ``` - * - * @param value The [GeoPoint] value. - * @return A new [Expression] constant instance. - */ - -public static final com.google.firebase.firestore.pipeline.Expression constant(com.google.firebase.firestore.GeoPoint value) { throw new RuntimeException("Stub!"); } - -/** - * Create a constant for a bytes value. - * - * ```kotlin - * // Create a constant with a byte array - * constant(byteArrayOf(0x48, 0x65, 0x6c, 0x6c, 0x6f)) // "Hello" - * ``` - * - * @param value The bytes value. - * @return A new [Expression] constant instance. - */ - -public static final com.google.firebase.firestore.pipeline.Expression constant(byte[] value) { throw new RuntimeException("Stub!"); } - -/** - * Create a constant for a [Blob] value. - * - * ```kotlin - * // Create a constant with a Blob - * constant(Blob.fromBytes(byteArrayOf(0x48, 0x65, 0x6c, 0x6c, 0x6f))) // "Hello" - * ``` - * - * @param value The [Blob] value. - * @return A new [Expression] constant instance. - */ - -public static final com.google.firebase.firestore.pipeline.Expression constant(com.google.firebase.firestore.Blob value) { throw new RuntimeException("Stub!"); } - -/** - * Create a constant for a [DocumentReference] value. - * - * ```kotlin - * // val firestore = FirebaseFirestore.getInstance() - * // val docRef = firestore.collection("cities").document("SF") - * // constant(docRef) - * ``` - * - * @param ref The [DocumentReference] value. - * @return A new [Expression] constant instance. - */ - -public static final com.google.firebase.firestore.pipeline.Expression constant(com.google.firebase.firestore.DocumentReference ref) { throw new RuntimeException("Stub!"); } - -/** - * Create a constant for a [VectorValue] value. - * - * ```kotlin - * // Create a constant with a VectorValue - * constant(VectorValue(listOf(1.0, 2.0, 3.0))) - * ``` - * - * @param value The [VectorValue] value. - * @return A new [Expression] constant instance. - */ - -public static final com.google.firebase.firestore.pipeline.Expression constant(com.google.firebase.firestore.VectorValue value) { throw new RuntimeException("Stub!"); } - -/** - * Constant for a null value. - * - * ```kotlin - * // Create a null constant - * nullValue() - * ``` - * - * @return A [Expression] constant instance. - */ - -public static final com.google.firebase.firestore.pipeline.Expression nullValue() { throw new RuntimeException("Stub!"); } - -/** - * Create a vector constant for a [DoubleArray] value. - * - * ```kotlin - * // Create a vector constant from a DoubleArray - * vector(doubleArrayOf(1.0, 2.0, 3.0)) - * ``` - * - * @param vector The [DoubleArray] value. - * @return A [Expression] constant instance. - */ - -public static final com.google.firebase.firestore.pipeline.Expression vector(double[] vector) { throw new RuntimeException("Stub!"); } - -/** - * Create a vector constant for a [VectorValue] value. - * - * ```kotlin - * // Create a vector constant from a VectorValue - * vector(VectorValue(listOf(1.0, 2.0, 3.0))) - * ``` - * - * @param vector The [VectorValue] value. - * @return A [Expression] constant instance. - */ - -public static final com.google.firebase.firestore.pipeline.Expression vector(com.google.firebase.firestore.VectorValue vector) { throw new RuntimeException("Stub!"); } - -/** - * Creates a [Field] instance representing the field at the given path. - * - * The path can be a simple field name (e.g., "name") or a dot-separated path to a nested field - * (e.g., "address.city"). - * - * @param name The path to the field. - * @return A new [Field] instance representing the specified path. - */ - -public static final com.google.firebase.firestore.pipeline.Field field(java.lang.String name) { throw new RuntimeException("Stub!"); } - -/** - * Creates a [Field] instance representing the field at the given path. - * - * The path can be a simple field name (e.g., "name") or a dot-separated path to a nested field - * (e.g., "address.city"). - * - * ```kotlin - * // Get the 'address.city' field - * field(FieldPath.of("address", "city")) - * ``` - * - * @param fieldPath The [FieldPath] to the field. - * @return A new [Field] instance representing the specified path. - */ - -public static final com.google.firebase.firestore.pipeline.Field field(com.google.firebase.firestore.FieldPath fieldPath) { throw new RuntimeException("Stub!"); } - -/** - * Creates a 'raw' function expression. This is useful if the expression is available in the - * backend, but not yet in the current version of the SDK yet. - * - * ```kotlin - * // Create a generic function call - * rawFunction("my_function", field("arg1"), constant(42)) - * ``` - * - * @param name The name of the raw function. - * @param expr The expressions to be passed as arguments to the function. - * @return A new [Expression] representing the raw function. - */ - -public static final com.google.firebase.firestore.pipeline.Expression rawFunction(java.lang.String name, com.google.firebase.firestore.pipeline.Expression... expr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that performs a logical 'AND' operation. - * - * ```kotlin - * // Check if 'status' is "new" and 'priority' is greater than 1 - * and(field("status").equal("new"), field("priority").greaterThan(1)) - * ``` - * - * @param condition The first [BooleanExpression]. - * @param conditions Additional [BooleanExpression]s. - * @return A new [BooleanExpression] representing the logical 'AND' operation. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression and(com.google.firebase.firestore.pipeline.BooleanExpression condition, com.google.firebase.firestore.pipeline.BooleanExpression... conditions) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that performs a logical 'OR' operation. - * - * ```kotlin - * // Check if 'status' is "new" or "open" - * or(field("status").equal("new"), field("status").equal("open")) - * ``` - * - * @param condition The first [BooleanExpression]. - * @param conditions Additional [BooleanExpression]s. - * @return A new [BooleanExpression] representing the logical 'OR' operation. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression or(com.google.firebase.firestore.pipeline.BooleanExpression condition, com.google.firebase.firestore.pipeline.BooleanExpression... conditions) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that performs a logical 'NOR' operation. - * - * ```kotlin - * // Check if 'status' is neither "new" nor "open" - * nor(field("status").equal("new"), field("status").equal("open")) - * ``` - * - * @param condition The first [BooleanExpression]. - * @param conditions Additional [BooleanExpression]s. - * @return A new [BooleanExpression] representing the logical 'NOR' operation. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression nor(com.google.firebase.firestore.pipeline.BooleanExpression condition, com.google.firebase.firestore.pipeline.BooleanExpression... conditions) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that evaluates to the result corresponding to the first true condition. - * - * This function behaves like a `switch` statement. It accepts an alternating sequence of - * conditions and their corresponding results. If an odd number of arguments is provided, the - * final argument serves as a default fallback result. If no default is provided and no - * condition evaluates to true, it throws an error. - * - * ```kotlin - * // Return "Active" if field "status" is 1, "Pending" if field "status" is 2, - * // and default to "Unknown" if none of the conditions are true. - * switchOn( - * field("status").equal(1), constant("Active"), - * field("status").equal(2), constant("Pending"), - * constant("Unknown") - * ) - * ``` - * - * @param condition The first condition to check. - * @param result The result if the first condition is true. - * @param others Additional conditions and results, and optionally a default value. - * @return A new [Expression] representing the switch operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression switchOn(com.google.firebase.firestore.pipeline.BooleanExpression condition, java.lang.Object result, java.lang.Object... others) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that performs a logical 'XOR' operation. - * - * ```kotlin - * // Check if either 'a' is true or 'b' is true, but not both - * xor(field("a"), field("b")) - * ``` - * - * @param condition The first [BooleanExpression]. - * @param conditions Additional [BooleanExpression]s. - * @return A new [BooleanExpression] representing the logical 'XOR' operation. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression xor(com.google.firebase.firestore.pipeline.BooleanExpression condition, com.google.firebase.firestore.pipeline.BooleanExpression... conditions) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that negates a boolean expression. - * - * ```kotlin - * // Check if 'is_admin' is not true - * not(field("is_admin")) - * ``` - * - * @param condition The boolean expression to negate. - * @return A new [BooleanExpression] representing the not operation. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression not(com.google.firebase.firestore.pipeline.BooleanExpression condition) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise AND operation between two expressions. - * - * ```kotlin - * // Bitwise AND the value of the 'flags' field with the value of the 'mask' field. - * bitAnd(field("flags"), field("mask")) - * ``` - * - * @param bits An expression that returns bits when evaluated. - * @param bitsOther An expression that returns bits when evaluated. - * @return A new [Expression] representing the bitwise AND operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression bitAnd(com.google.firebase.firestore.pipeline.Expression bits, com.google.firebase.firestore.pipeline.Expression bitsOther) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise AND operation between an expression and a - * constant. - * - * ```kotlin - * // Bitwise AND the value of the 'flags' field with a constant mask. - * bitAnd(field("flags"), byteArrayOf(0b00001111)) - * ``` - * - * @param bits An expression that returns bits when evaluated. - * @param bitsOther A constant byte array. - * @return A new [Expression] representing the bitwise AND operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression bitAnd(com.google.firebase.firestore.pipeline.Expression bits, byte[] bitsOther) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise AND operation between an field and an - * expression. - * - * ```kotlin - * // Bitwise AND the value of the 'flags' field with the value of the 'mask' field. - * bitAnd("flags", field("mask")) - * ``` - * - * @param bitsFieldName Name of field that contains bits data. - * @param bitsOther An expression that returns bits when evaluated. - * @return A new [Expression] representing the bitwise AND operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression bitAnd(java.lang.String bitsFieldName, com.google.firebase.firestore.pipeline.Expression bitsOther) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise AND operation between an field and constant. - * - * ```kotlin - * // Bitwise AND the value of the 'flags' field with a constant mask. - * bitAnd("flags", byteArrayOf(0b00001111)) - * ``` - * - * @param bitsFieldName Name of field that contains bits data. - * @param bitsOther A constant byte array. - * @return A new [Expression] representing the bitwise AND operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression bitAnd(java.lang.String bitsFieldName, byte[] bitsOther) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise OR operation between two expressions. - * - * ```kotlin - * // Bitwise OR the value of the 'flags' field with the value of the 'mask' field. - * bitOr(field("flags"), field("mask")) - * ``` - * - * @param bits An expression that returns bits when evaluated. - * @param bitsOther An expression that returns bits when evaluated. - * @return A new [Expression] representing the bitwise OR operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression bitOr(com.google.firebase.firestore.pipeline.Expression bits, com.google.firebase.firestore.pipeline.Expression bitsOther) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise OR operation between an expression and a - * constant. - * - * ```kotlin - * // Bitwise OR the value of the 'flags' field with a constant mask. - * bitOr(field("flags"), byteArrayOf(0b00001111)) - * ``` - * - * @param bits An expression that returns bits when evaluated. - * @param bitsOther A constant byte array. - * @return A new [Expression] representing the bitwise OR operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression bitOr(com.google.firebase.firestore.pipeline.Expression bits, byte[] bitsOther) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise OR operation between an field and an expression. - * - * ```kotlin - * // Bitwise OR the value of the 'flags' field with the value of the 'mask' field. - * bitOr("flags", field("mask")) - * ``` - * - * @param bitsFieldName Name of field that contains bits data. - * @param bitsOther An expression that returns bits when evaluated. - * @return A new [Expression] representing the bitwise OR operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression bitOr(java.lang.String bitsFieldName, com.google.firebase.firestore.pipeline.Expression bitsOther) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise OR operation between an field and constant. - * - * ```kotlin - * // Bitwise OR the value of the 'flags' field with a constant mask. - * bitOr("flags", byteArrayOf(0b00001111)) - * ``` - * - * @param bitsFieldName Name of field that contains bits data. - * @param bitsOther A constant byte array. - * @return A new [Expression] representing the bitwise OR operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression bitOr(java.lang.String bitsFieldName, byte[] bitsOther) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise XOR operation between two expressions. - * - * ```kotlin - * // Bitwise XOR the value of the 'flags' field with the value of the 'mask' field. - * bitXor(field("flags"), field("mask")) - * ``` - * - * @param bits An expression that returns bits when evaluated. - * @param bitsOther An expression that returns bits when evaluated. - * @return A new [Expression] representing the bitwise XOR operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression bitXor(com.google.firebase.firestore.pipeline.Expression bits, com.google.firebase.firestore.pipeline.Expression bitsOther) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise XOR operation between an expression and a - * constant. - * - * ```kotlin - * // Bitwise XOR the value of the 'flags' field with a constant mask. - * bitXor(field("flags"), byteArrayOf(0b00001111)) - * ``` - * - * @param bits An expression that returns bits when evaluated. - * @param bitsOther A constant byte array. - * @return A new [Expression] representing the bitwise XOR operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression bitXor(com.google.firebase.firestore.pipeline.Expression bits, byte[] bitsOther) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise XOR operation between an field and an - * expression. - * - * ```kotlin - * // Bitwise XOR the value of the 'flags' field with the value of the 'mask' field. - * bitXor("flags", field("mask")) - * ``` - * - * @param bitsFieldName Name of field that contains bits data. - * @param bitsOther An expression that returns bits when evaluated. - * @return A new [Expression] representing the bitwise XOR operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression bitXor(java.lang.String bitsFieldName, com.google.firebase.firestore.pipeline.Expression bitsOther) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise XOR operation between an field and constant. - * - * ```kotlin - * // Bitwise XOR the value of the 'flags' field with a constant mask. - * bitXor("flags", byteArrayOf(0b00001111)) - * ``` - * - * @param bitsFieldName Name of field that contains bits data. - * @param bitsOther A constant byte array. - * @return A new [Expression] representing the bitwise XOR operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression bitXor(java.lang.String bitsFieldName, byte[] bitsOther) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise NOT operation to an expression. - * - * ```kotlin - * // Bitwise NOT the value of the 'flags' field. - * bitNot(field("flags")) - * ``` - * - * @param bits An expression that returns bits when evaluated. - * @return A new [Expression] representing the bitwise NOT operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression bitNot(com.google.firebase.firestore.pipeline.Expression bits) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise NOT operation to a field. - * - * ```kotlin - * // Bitwise NOT the value of the 'flags' field. - * bitNot("flags") - * ``` - * - * @param bitsFieldName Name of field that contains bits data. - * @return A new [Expression] representing the bitwise NOT operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression bitNot(java.lang.String bitsFieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise left shift operation between two expressions. - * - * ```kotlin - * // Left shift the value of the 'bits' field by the value of the 'shift' field. - * bitLeftShift(field("bits"), field("shift")) - * ``` - * - * @param bits An expression that returns bits when evaluated. - * @param numberExpr The number of bits to shift. - * @return A new [Expression] representing the bitwise left shift operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression bitLeftShift(com.google.firebase.firestore.pipeline.Expression bits, com.google.firebase.firestore.pipeline.Expression numberExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise left shift operation between an expression and a - * constant. - * - * ```kotlin - * // Left shift the value of the 'bits' field by 2. - * bitLeftShift(field("bits"), 2) - * ``` - * - * @param bits An expression that returns bits when evaluated. - * @param number The number of bits to shift. - * @return A new [Expression] representing the bitwise left shift operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression bitLeftShift(com.google.firebase.firestore.pipeline.Expression bits, int number) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise left shift operation between a field and an - * expression. - * - * ```kotlin - * // Left shift the value of the 'bits' field by the value of the 'shift' field. - * bitLeftShift("bits", field("shift")) - * ``` - * - * @param bitsFieldName Name of field that contains bits data. - * @param numberExpr The number of bits to shift. - * @return A new [Expression] representing the bitwise left shift operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression bitLeftShift(java.lang.String bitsFieldName, com.google.firebase.firestore.pipeline.Expression numberExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise left shift operation between a field and a - * constant. - * - * ```kotlin - * // Left shift the value of the 'bits' field by 2. - * bitLeftShift("bits", 2) - * ``` - * - * @param bitsFieldName Name of field that contains bits data. - * @param number The number of bits to shift. - * @return A new [Expression] representing the bitwise left shift operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression bitLeftShift(java.lang.String bitsFieldName, int number) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise right shift operation between two expressions. - * - * ```kotlin - * // Right shift the value of the 'bits' field by the value of the 'shift' field. - * bitRightShift(field("bits"), field("shift")) - * ``` - * - * @param bits An expression that returns bits when evaluated. - * @param numberExpr The number of bits to shift. - * @return A new [Expression] representing the bitwise right shift operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression bitRightShift(com.google.firebase.firestore.pipeline.Expression bits, com.google.firebase.firestore.pipeline.Expression numberExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise right shift operation between an expression and - * a constant. - * - * ```kotlin - * // Right shift the value of the 'bits' field by 2. - * bitRightShift(field("bits"), 2) - * ``` - * - * @param bits An expression that returns bits when evaluated. - * @param number The number of bits to shift. - * @return A new [Expression] representing the bitwise right shift operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression bitRightShift(com.google.firebase.firestore.pipeline.Expression bits, int number) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise right shift operation between a field and an - * expression. - * - * ```kotlin - * // Right shift the value of the 'bits' field by the value of the 'shift' field. - * bitRightShift("bits", field("shift")) - * ``` - * - * @param bitsFieldName Name of field that contains bits data. - * @param numberExpr The number of bits to shift. - * @return A new [Expression] representing the bitwise right shift operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression bitRightShift(java.lang.String bitsFieldName, com.google.firebase.firestore.pipeline.Expression numberExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise right shift operation between a field and a - * constant. - * - * ```kotlin - * // Right shift the value of the 'bits' field by 2. - * bitRightShift("bits", 2) - * ``` - * - * @param bitsFieldName Name of field that contains bits data. - * @param number The number of bits to shift. - * @return A new [Expression] representing the bitwise right shift operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression bitRightShift(java.lang.String bitsFieldName, int number) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that rounds [numericExpr] to nearest integer. - * - * ```kotlin - * // Round the value of the 'price' field. - * round(field("price")) - * ``` - * - * Rounds away from zero in halfway cases. - * - * @param numericExpr An expression that returns number when evaluated. - * @return A new [Expression] representing an integer result from the round operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression round(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that rounds [numericField] to nearest integer. - * - * ```kotlin - * // Round the value of the 'price' field. - * round("price") - * ``` - * - * Rounds away from zero in halfway cases. - * - * @param numericField Name of field that returns number when evaluated. - * @return A new [Expression] representing an integer result from the round operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression round(java.lang.String numericField) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that rounds off [numericExpr] to [decimalPlace] decimal places if - * [decimalPlace] is positive, rounds off digits to the left of the decimal point if - * [decimalPlace] is negative. Rounds away from zero in halfway cases. - * - * ```kotlin - * // Round the value of the 'price' field to 2 decimal places. - * roundToPrecision(field("price"), 2) - * ``` - * - * @param numericExpr An expression that returns number when evaluated. - * @param decimalPlace The number of decimal places to round. - * @return A new [Expression] representing the round operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression roundToPrecision(com.google.firebase.firestore.pipeline.Expression numericExpr, int decimalPlace) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that rounds off [numericField] to [decimalPlace] decimal places if - * [decimalPlace] is positive, rounds off digits to the left of the decimal point if - * [decimalPlace] is negative. Rounds away from zero in halfway cases. - * - * ```kotlin - * // Round the value of the 'price' field to 2 decimal places. - * roundToPrecision("price", 2) - * ``` - * - * @param numericField Name of field that returns number when evaluated. - * @param decimalPlace The number of decimal places to round. - * @return A new [Expression] representing the round operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression roundToPrecision(java.lang.String numericField, int decimalPlace) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that rounds off [numericExpr] to [decimalPlace] decimal places if - * [decimalPlace] is positive, rounds off digits to the left of the decimal point if - * [decimalPlace] is negative. Rounds away from zero in halfway cases. - * - * ```kotlin - * // Round the value of the 'price' field to the number of decimal places specified in the - * // 'precision' field. - * roundToPrecision(field("price"), field("precision")) - * ``` - * - * @param numericExpr An expression that returns number when evaluated. - * @param decimalPlace The number of decimal places to round. - * @return A new [Expression] representing the round operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression roundToPrecision(com.google.firebase.firestore.pipeline.Expression numericExpr, com.google.firebase.firestore.pipeline.Expression decimalPlace) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that rounds off [numericField] to [decimalPlace] decimal places if - * [decimalPlace] is positive, rounds off digits to the left of the decimal point if - * [decimalPlace] is negative. Rounds away from zero in halfway cases. - * - * ```kotlin - * // Round the value of the 'price' field to the number of decimal places specified in the - * // 'precision' field. - * roundToPrecision("price", field("precision")) - * ``` - * - * @param numericField Name of field that returns number when evaluated. - * @param decimalPlace The number of decimal places to round. - * @return A new [Expression] representing the round operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression roundToPrecision(java.lang.String numericField, com.google.firebase.firestore.pipeline.Expression decimalPlace) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates [numericExpr] to an integer. - * - * ```kotlin - * // Truncate the value of the 'rating' field. - * trunc(field("rating")) - * ``` - * - * @param numericExpr An expression that returns number when evaluated. - * @return A new [Expression] representing the truncate operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression trunc(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates [numericField] to an integer. - * - * ```kotlin - * // Truncate the value of the 'rating' field. - * trunc("rating") - * ``` - * - * @param numericField Name of field that returns number when evaluated. - * @return A new [Expression] representing the truncate operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression trunc(java.lang.String numericField) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates [numericExpr] to [decimalPlace] decimal places if - * [decimalPlace] is positive, truncates digits to the left of the decimal point if - * [decimalPlace] is negative. - * - * ```kotlin - * // Truncate the value of the 'rating' field to 2 decimal places. - * truncToPrecision(field("rating"), 2) - * ``` - * - * @param numericExpr An expression that returns number when evaluated. - * @param decimalPlace The number of decimal places to truncate. - * @return A new [Expression] representing the truncate operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression truncToPrecision(com.google.firebase.firestore.pipeline.Expression numericExpr, int decimalPlace) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates [numericField] to [decimalPlace] decimal places if - * [decimalPlace] is positive, truncates digits to the left of the decimal point if - * [decimalPlace] is negative. - * - * ```kotlin - * // Truncate the value of the 'rating' field to 2 decimal places. - * truncToPrecision("rating", 2) - * ``` - * - * @param numericField Name of field that returns number when evaluated. - * @param decimalPlace The number of decimal places to truncate. - * @return A new [Expression] representing the truncate operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression truncToPrecision(java.lang.String numericField, int decimalPlace) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates [numericExpr] to [decimalPlace] decimal places if - * [decimalPlace] is positive, truncates digits to the left of the decimal point if - * [decimalPlace] is negative. - * - * ```kotlin - * // Truncate the value of the 'rating' field to the number of decimal places specified in the - * // 'precision' field. - * truncToPrecision(field("rating"), field("precision")) - * ``` - * - * @param numericExpr An expression that returns number when evaluated. - * @param decimalPlace The number of decimal places to truncate. - * @return A new [Expression] representing the truncate operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression truncToPrecision(com.google.firebase.firestore.pipeline.Expression numericExpr, com.google.firebase.firestore.pipeline.Expression decimalPlace) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates [numericField] to [decimalPlace] decimal places if - * [decimalPlace] is positive, truncates digits to the left of the decimal point if - * [decimalPlace] is negative. - * - * ```kotlin - * // Truncate the value of the 'rating' field to the number of decimal places specified in the - * // 'precision' field. - * truncToPrecision("rating", field("precision")) - * ``` - * - * @param numericField Name of field that returns number when evaluated. - * @param decimalPlace The number of decimal places to truncate. - * @return A new [Expression] representing the truncate operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression truncToPrecision(java.lang.String numericField, com.google.firebase.firestore.pipeline.Expression decimalPlace) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the smallest integer that isn't less than [numericExpr]. - * - * ```kotlin - * // Compute the ceiling of the 'price' field. - * ceil(field("price")) - * ``` - * - * @param numericExpr An expression that returns number when evaluated. - * @return A new [Expression] representing an integer result from the ceil operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression ceil(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the smallest integer that isn't less than [numericField]. - * - * ```kotlin - * // Compute the ceiling of the 'price' field. - * ceil("price") - * ``` - * - * @param numericField Name of field that returns number when evaluated. - * @return A new [Expression] representing an integer result from the ceil operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression ceil(java.lang.String numericField) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the largest integer that is not greater than [numericExpr] - * - * ```kotlin - * // Compute the floor of the 'price' field. - * floor(field("price")) - * ``` - * - * @param numericExpr An expression that returns number when evaluated. - * @return A new [Expression] representing an integer result from the floor operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression floor(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the largest integer that is not greater than - * [numericField]. - * - * ```kotlin - * // Compute the floor of the 'price' field. - * floor("price") - * ``` - * - * @param numericField Name of field that returns number when evaluated. - * @return A new [Expression] representing an integer result from the floor operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression floor(java.lang.String numericField) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [numericExpr] raised to the power of the [exponent]. - * Returns infinity on overflow and zero on underflow. - * - * ```kotlin - * // Raise the value of the 'base' field to the power of 2. - * pow(field("base"), 2) - * ``` - * - * @param numericExpr An expression that returns number when evaluated. - * @param exponent The numeric power to raise the [numericExpr]. - * @return A new [Expression] representing a numeric result from raising [numericExpr] to the - * power of [exponent]. - */ - -public static final com.google.firebase.firestore.pipeline.Expression pow(com.google.firebase.firestore.pipeline.Expression numericExpr, java.lang.Number exponent) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [numericField] raised to the power of the [exponent]. - * Returns infinity on overflow and zero on underflow. - * - * ```kotlin - * // Raise the value of the 'base' field to the power of 2. - * pow("base", 2) - * ``` - * - * @param numericField Name of field that returns number when evaluated. - * @param exponent The numeric power to raise the [numericField]. - * @return A new [Expression] representing a numeric result from raising [numericField] to the - * power of [exponent]. - */ - -public static final com.google.firebase.firestore.pipeline.Expression pow(java.lang.String numericField, java.lang.Number exponent) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [numericExpr] raised to the power of the [exponent]. - * Returns infinity on overflow and zero on underflow. - * - * ```kotlin - * // Raise the value of the 'base' field to the power of the 'exponent' field. - * pow(field("base"), field("exponent")) - * ``` - * - * @param numericExpr An expression that returns number when evaluated. - * @param exponent The numeric power to raise the [numericExpr]. - * @return A new [Expression] representing a numeric result from raising [numericExpr] to the - * power of [exponent]. - */ - -public static final com.google.firebase.firestore.pipeline.Expression pow(com.google.firebase.firestore.pipeline.Expression numericExpr, com.google.firebase.firestore.pipeline.Expression exponent) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [numericField] raised to the power of the [exponent]. - * Returns infinity on overflow and zero on underflow. - * - * ```kotlin - * // Raise the value of the 'base' field to the power of the 'exponent' field. - * pow("base", field("exponent")) - * ``` - * - * @param numericField Name of field that returns number when evaluated. - * @param exponent The numeric power to raise the [numericField]. - * @return A new [Expression] representing a numeric result from raising [numericField] to the - * power of [exponent]. - */ - -public static final com.google.firebase.firestore.pipeline.Expression pow(java.lang.String numericField, com.google.firebase.firestore.pipeline.Expression exponent) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the absolute value of [numericExpr]. - * - * ```kotlin - * // Get the absolute value of the 'change' field. - * abs(field("change")) - * ``` - * - * @param numericExpr An expression that returns number when evaluated. - * @return A new [Expression] representing the numeric result of the absolute value operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression abs(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the absolute value of [numericField]. - * - * ```kotlin - * // Get the absolute value of the 'change' field. - * abs("change") - * ``` - * - * @param numericField Name of field that returns number when evaluated. - * @return A new [Expression] representing the numeric result of the absolute value operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression abs(java.lang.String numericField) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns Euler's number e raised to the power of [numericExpr]. - * - * ```kotlin - * // Compute e to the power of the 'value' field. - * exp(field("value")) - * ``` - * - * @param numericExpr An expression that returns number when evaluated. - * @return A new [Expression] representing the numeric result of the exponentiation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression exp(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns Euler's number e raised to the power of [numericField]. - * - * ```kotlin - * // Compute e to the power of the 'value' field. - * exp("value") - * ``` - * - * @param numericField Name of field that returns number when evaluated. - * @return A new [Expression] representing the numeric result of the exponentiation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression exp(java.lang.String numericField) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the natural logarithm (base e) of [numericExpr]. - * - * ```kotlin - * // Compute the natural logarithm of the 'value' field. - * ln(field("value")) - * ``` - * - * @param numericExpr An expression that returns number when evaluated. - * @return A new [Expression] representing the numeric result of the natural logarithm. - */ - -public static final com.google.firebase.firestore.pipeline.Expression ln(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the natural logarithm (base e) of [numericField]. - * - * ```kotlin - * // Compute the natural logarithm of the 'value' field. - * ln("value") - * ``` - * - * @param numericField Name of field that returns number when evaluated. - * @return A new [Expression] representing the numeric result of the natural logarithm. - */ - -public static final com.google.firebase.firestore.pipeline.Expression ln(java.lang.String numericField) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the logarithm of [numericExpr] with a given [base]. - * - * ```kotlin - * // Compute the logarithm of the 'value' field with base 10. - * log(field("value"), 10) - * ``` - * - * @param numericExpr An expression that returns number when evaluated. - * @param base The base of the logarithm. - * @return A new [Expression] representing a numeric result from the logarithm of [numericExpr] - * with a given [base]. - */ - -public static final com.google.firebase.firestore.pipeline.Expression log(com.google.firebase.firestore.pipeline.Expression numericExpr, java.lang.Number base) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the logarithm of [numericField] with a given [base]. - * - * ```kotlin - * // Compute the logarithm of the 'value' field with base 10. - * log("value", 10) - * ``` - * - * @param numericField Name of field that returns number when evaluated. - * @param base The base of the logarithm. - * @return A new [Expression] representing a numeric result from the logarithm of [numericField] - * with a given [base]. - */ - -public static final com.google.firebase.firestore.pipeline.Expression log(java.lang.String numericField, java.lang.Number base) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the logarithm of [numericExpr] with a given [base]. - * - * ```kotlin - * // Compute the logarithm of the 'value' field with the base in the 'base' field. - * log(field("value"), field("base")) - * ``` - * - * @param numericExpr An expression that returns number when evaluated. - * @param base The base of the logarithm. - * @return A new [Expression] representing a numeric result from the logarithm of [numericExpr] - * with a given [base]. - */ - -public static final com.google.firebase.firestore.pipeline.Expression log(com.google.firebase.firestore.pipeline.Expression numericExpr, com.google.firebase.firestore.pipeline.Expression base) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the logarithm of [numericField] with a given [base]. - * - * ```kotlin - * // Compute the logarithm of the 'value' field with the base in the 'base' field. - * log("value", field("base")) - * ``` - * - * @param numericField Name of field that returns number when evaluated. - * @param base The base of the logarithm. - * @return A new [Expression] representing a numeric result from the logarithm of [numericField] - * with a given [base]. - */ - -public static final com.google.firebase.firestore.pipeline.Expression log(java.lang.String numericField, com.google.firebase.firestore.pipeline.Expression base) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the base 10 logarithm of [numericExpr]. - * - * ```kotlin - * // Compute the base 10 logarithm of the 'value' field. - * log10(field("value")) - * ``` - * - * @param numericExpr An expression that returns number when evaluated. - * @return A new [Expression] representing the numeric result of the base 10 logarithm. - */ - -public static final com.google.firebase.firestore.pipeline.Expression log10(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the base 10 logarithm of [numericField]. - * - * ```kotlin - * // Compute the base 10 logarithm of the 'value' field. - * log10("value") - * ``` - * - * @param numericField Name of field that returns number when evaluated. - * @return A new [Expression] representing the numeric result of the base 10 logarithm. - */ - -public static final com.google.firebase.firestore.pipeline.Expression log10(java.lang.String numericField) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the square root of [numericExpr]. - * - * ```kotlin - * // Compute the square root of the 'value' field. - * sqrt(field("value")) - * ``` - * - * @param numericExpr An expression that returns number when evaluated. - * @return A new [Expression] representing the numeric result of the square root operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression sqrt(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the square root of [numericField]. - * - * ```kotlin - * // Compute the square root of the 'value' field. - * sqrt("value") - * ``` - * - * @param numericField Name of field that returns number when evaluated. - * @return A new [Expression] representing the numeric result of the square root operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression sqrt(java.lang.String numericField) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that adds numeric expressions. - * - * ```kotlin - * // Add the value of the 'quantity' field and the 'reserve' field. - * add(field("quantity"), field("reserve")) - * ``` - * - * @param first Numeric expression to add. - * @param second Numeric expression to add. - * @return A new [Expression] representing the addition operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression add(com.google.firebase.firestore.pipeline.Expression first, com.google.firebase.firestore.pipeline.Expression second) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that adds numeric expressions with a constant. - * - * ```kotlin - * // Add 5 to the value of the 'quantity' field. - * add(field("quantity"), 5) - * ``` - * - * @param first Numeric expression to add. - * @param second Constant to add. - * @return A new [Expression] representing the addition operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression add(com.google.firebase.firestore.pipeline.Expression first, java.lang.Number second) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that adds a numeric field with a numeric expression. - * - * ```kotlin - * // Add the value of the 'quantity' field and the 'reserve' field. - * add("quantity", field("reserve")) - * ``` - * - * @param numericFieldName Numeric field to add. - * @param second Numeric expression to add to field value. - * @return A new [Expression] representing the addition operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression add(java.lang.String numericFieldName, com.google.firebase.firestore.pipeline.Expression second) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that adds a numeric field with constant. - * - * ```kotlin - * // Add 5 to the value of the 'quantity' field. - * add("quantity", 5) - * ``` - * - * @param numericFieldName Numeric field to add. - * @param second Constant to add. - * @return A new [Expression] representing the addition operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression add(java.lang.String numericFieldName, java.lang.Number second) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that subtracts two expressions. - * - * ```kotlin - * // Subtract the 'discount' field from the 'price' field - * subtract(field("price"), field("discount")) - * ``` - * - * @param minuend Numeric expression to subtract from. - * @param subtrahend Numeric expression to subtract. - * @return A new [Expression] representing the subtract operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression subtract(com.google.firebase.firestore.pipeline.Expression minuend, com.google.firebase.firestore.pipeline.Expression subtrahend) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that subtracts a constant value from a numeric expression. - * - * ```kotlin - * // Subtract 10 from the 'price' field. - * subtract(field("price"), 10) - * ``` - * - * @param minuend Numeric expression to subtract from. - * @param subtrahend Constant to subtract. - * @return A new [Expression] representing the subtract operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression subtract(com.google.firebase.firestore.pipeline.Expression minuend, java.lang.Number subtrahend) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that subtracts a numeric expressions from numeric field. - * - * ```kotlin - * // Subtract the 'discount' field from the 'price' field. - * subtract("price", field("discount")) - * ``` - * - * @param numericFieldName Numeric field to subtract from. - * @param subtrahend Numeric expression to subtract. - * @return A new [Expression] representing the subtract operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression subtract(java.lang.String numericFieldName, com.google.firebase.firestore.pipeline.Expression subtrahend) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that subtracts a constant from numeric field. - * - * ```kotlin - * // Subtract 10 from the 'price' field. - * subtract("price", 10) - * ``` - * - * @param numericFieldName Numeric field to subtract from. - * @param subtrahend Constant to subtract. - * @return A new [Expression] representing the subtract operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression subtract(java.lang.String numericFieldName, java.lang.Number subtrahend) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that multiplies numeric expressions. - * - * ```kotlin - * // Multiply the 'quantity' field by the 'price' field - * multiply(field("quantity"), field("price")) - * ``` - * - * @param first Numeric expression to multiply. - * @param second Numeric expression to multiply. - * @return A new [Expression] representing the multiplication operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression multiply(com.google.firebase.firestore.pipeline.Expression first, com.google.firebase.firestore.pipeline.Expression second) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that multiplies numeric expressions with a constant. - * - * ```kotlin - * // Multiply the 'quantity' field by 1.1. - * multiply(field("quantity"), 1.1) - * ``` - * - * @param first Numeric expression to multiply. - * @param second Constant to multiply. - * @return A new [Expression] representing the multiplication operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression multiply(com.google.firebase.firestore.pipeline.Expression first, java.lang.Number second) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that multiplies a numeric field with a numeric expression. - * - * ```kotlin - * // Multiply the 'quantity' field by the 'price' field. - * multiply("quantity", field("price")) - * ``` - * - * @param numericFieldName Numeric field to multiply. - * @param second Numeric expression to multiply. - * @return A new [Expression] representing the multiplication operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression multiply(java.lang.String numericFieldName, com.google.firebase.firestore.pipeline.Expression second) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that multiplies a numeric field with a constant. - * - * ```kotlin - * // Multiply the 'quantity' field by 1.1. - * multiply("quantity", 1.1) - * ``` - * - * @param numericFieldName Numeric field to multiply. - * @param second Constant to multiply. - * @return A new [Expression] representing the multiplication operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression multiply(java.lang.String numericFieldName, java.lang.Number second) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that divides two numeric expressions. - * - * ```kotlin - * // Divide the 'total' field by the 'count' field - * divide(field("total"), field("count")) - * ``` - * - * @param dividend The numeric expression to be divided. - * @param divisor The numeric expression to divide by. - * @return A new [Expression] representing the division operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression divide(com.google.firebase.firestore.pipeline.Expression dividend, com.google.firebase.firestore.pipeline.Expression divisor) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that divides a numeric expression by a constant. - * - * ```kotlin - * // Divide the 'value' field by 10 - * divide(field("value"), 10) - * ``` - * - * @param dividend The numeric expression to be divided. - * @param divisor The constant to divide by. - * @return A new [Expression] representing the division operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression divide(com.google.firebase.firestore.pipeline.Expression dividend, java.lang.Number divisor) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that divides numeric field by a numeric expression. - * - * ```kotlin - * // Divide the 'total' field by the 'count' field. - * divide("total", field("count")) - * ``` - * - * @param dividendFieldName The numeric field name to be divided. - * @param divisor The numeric expression to divide by. - * @return A new [Expression] representing the divide operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression divide(java.lang.String dividendFieldName, com.google.firebase.firestore.pipeline.Expression divisor) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that divides a numeric field by a constant. - * - * ```kotlin - * // Divide the 'total' field by 2. - * divide("total", 2) - * ``` - * - * @param dividendFieldName The numeric field name to be divided. - * @param divisor The constant to divide by. - * @return A new [Expression] representing the divide operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression divide(java.lang.String dividendFieldName, java.lang.Number divisor) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the modulo (remainder) of dividing two numeric - * expressions. - * - * ```kotlin - * // Calculate the remainder of dividing the 'value' field by the 'divisor' field - * mod(field("value"), field("divisor")) - * ``` - * - * @param dividend The numeric expression to be divided. - * @param divisor The numeric expression to divide by. - * @return A new [Expression] representing the modulo operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression mod(com.google.firebase.firestore.pipeline.Expression dividend, com.google.firebase.firestore.pipeline.Expression divisor) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the modulo (remainder) of dividing a numeric expression - * by a constant. - * - * ```kotlin - * // Calculate the remainder of dividing the 'value' field by 3. - * mod(field("value"), 3) - * ``` - * - * @param dividend The numeric expression to be divided. - * @param divisor The constant to divide by. - * @return A new [Expression] representing the modulo operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression mod(com.google.firebase.firestore.pipeline.Expression dividend, java.lang.Number divisor) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the modulo (remainder) of dividing a numeric field by a - * constant. - * - * ```kotlin - * // Calculate the remainder of dividing the 'value' field by the 'divisor' field. - * mod("value", field("divisor")) - * ``` - * - * @param dividendFieldName The numeric field name to be divided. - * @param divisor The numeric expression to divide by. - * @return A new [Expression] representing the modulo operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression mod(java.lang.String dividendFieldName, com.google.firebase.firestore.pipeline.Expression divisor) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the modulo (remainder) of dividing a numeric field by a - * constant. - * - * ```kotlin - * // Calculate the remainder of dividing the 'value' field by 3. - * mod("value", 3) - * ``` - * - * @param dividendFieldName The numeric field name to be divided. - * @param divisor The constant to divide by. - * @return A new [Expression] representing the modulo operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression mod(java.lang.String dividendFieldName, java.lang.Number divisor) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if an [expression], when evaluated, is equal to any of the - * provided [values]. - * - * ```kotlin - * // Check if the 'category' field is either "Electronics" or the value of the 'primaryType' field. - * equalAny(field("category"), listOf("Electronics", field("primaryType"))) - * ``` - * - * @param expression The expression whose results to compare. - * @param values The values to check against. - * @return A new [BooleanExpression] representing the 'IN' comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression equalAny(com.google.firebase.firestore.pipeline.Expression expression, java.util.List values) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if an [expression], when evaluated, is equal to any of the - * elements of [arrayExpression]. - * - * ```kotlin - * // Check if the 'category' field is in the 'availableCategories' array field. - * equalAny(field("category"), field("availableCategories")) - * ``` - * - * @param expression The expression whose results to compare. - * @param arrayExpression An expression that evaluates to an array, whose elements to check for - * equality to the input. - * @return A new [BooleanExpression] representing the 'IN' comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression equalAny(com.google.firebase.firestore.pipeline.Expression expression, com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field's value is equal to any of the provided [values] - * . - * - * ```kotlin - * // Check if the 'category' field is either "Electronics" or "Apparel". - * equalAny("category", listOf("Electronics", "Apparel")) - * ``` - * - * @param fieldName The field to compare. - * @param values The values to check against. - * @return A new [BooleanExpression] representing the 'IN' comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression equalAny(java.lang.String fieldName, java.util.List values) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field's value is equal to any of the elements of - * [arrayExpression]. - * - * ```kotlin - * // Check if the 'category' field is in the 'availableCategories' array field. - * equalAny("category", field("availableCategories")) - * ``` - * - * @param fieldName The field to compare. - * @param arrayExpression An expression that evaluates to an array, whose elements to check for - * equality to the input. - * @return A new [BooleanExpression] representing the 'IN' comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression equalAny(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if an [expression], when evaluated, is not equal to all the - * provided [values]. - * - * ```kotlin - * // Check if the 'status' field is neither "pending" nor the value of the 'rejectedStatus' field. - * notEqualAny(field("status"), listOf("pending", field("rejectedStatus"))) - * ``` - * - * @param expression The expression whose results to compare. - * @param values The values to check against. - * @return A new [BooleanExpression] representing the 'NOT IN' comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression notEqualAny(com.google.firebase.firestore.pipeline.Expression expression, java.util.List values) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if an [expression], when evaluated, is not equal to all the - * elements of [arrayExpression]. - * - * ```kotlin - * // Check if the 'status' field is not in the 'inactiveStatuses' array field. - * notEqualAny(field("status"), field("inactiveStatuses")) - * ``` - * - * @param expression The expression whose results to compare. - * @param arrayExpression An expression that evaluates to an array, whose elements to check for - * equality to the input. - * @return A new [BooleanExpression] representing the 'NOT IN' comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression notEqualAny(com.google.firebase.firestore.pipeline.Expression expression, com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field's value is not equal to all of the provided - * [values]. - * - * ```kotlin - * // Check if the 'status' field is not "archived" or "deleted". - * notEqualAny("status", listOf("archived", "deleted")) - * ``` - * - * @param fieldName The field to compare. - * @param values The values to check against. - * @return A new [BooleanExpression] representing the 'NOT IN' comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression notEqualAny(java.lang.String fieldName, java.util.List values) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field's value is not equal to all of the elements of - * [arrayExpression]. - * - * ```kotlin - * // Check if the 'status' field is not in the 'inactiveStatuses' array field. - * notEqualAny("status", field("inactiveStatuses")) - * ``` - * - * @param fieldName The field to compare. - * @param arrayExpression An expression that evaluates to an array, whose elements to check for - * equality to the input. - * @return A new [BooleanExpression] representing the 'NOT IN' comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression notEqualAny(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns true if a value is absent. Otherwise, returns false even - * if the value is null. - * - * ```kotlin - * // Check if the field `value` is absent. - * isAbsent(field("value")) - * ``` - * - * @param value The expression to check. - * @return A new [BooleanExpression] representing the isAbsent operation. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression isAbsent(com.google.firebase.firestore.pipeline.Expression value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns true if a field is absent. Otherwise, returns false even - * if the field value is null. - * - * ```kotlin - * // Check if the field `value` is absent. - * isAbsent("value") - * ``` - * - * @param fieldName The field to check. - * @return A new [BooleanExpression] representing the isAbsent operation. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression isAbsent(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a string indicating the type of the value this expression - * evaluates to. - * - * ```kotlin - * // Get the type of the 'value' field. - * type(field("value")) - * ``` - * - * @param expr The expression to get the type of. - * @return A new [Expression] representing the type operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression type(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a string indicating the type of the value this field - * evaluates to. - * - * ```kotlin - * // Get the type of the 'field' field. - * type("field") - * ``` - * - * @param fieldName The name of the field to get the type of. - * @return A new [Expression] representing the type operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression type(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if the result of an expression is of the given type. - * - * Supported values for `type` are: "null", "array", "boolean", "bytes", "timestamp", - * "geo_point", "number", "int32", "int64", "float64", "decimal128", "map", "reference", - * "string", "vector", "max_key", "min_key", "object_id", "regex", and "request_timestamp". - * - * ```kotlin - * // Check if the 'age' field is an integer - * isType(field("age"), "int64") - * ``` - * - * @param expr The expression to check the type of. - * @param type The type to check for. - * @return A new [BooleanExpression] that evaluates to true if the expression's result is of the - * given type, false otherwise. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression isType(com.google.firebase.firestore.pipeline.Expression expr, java.lang.String type) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if the value of a field is of the given type. - * - * Supported values for `type` are: "null", "array", "boolean", "bytes", "timestamp", - * "geo_point", "number", "int32", "int64", "float64", "decimal128", "map", "reference", - * "string", "vector", "max_key", "min_key", "object_id", "regex", and "request_timestamp". - * - * ```kotlin - * // Check if the 'age' field is an integer - * isType("age", "int64") - * ``` - * - * @param fieldName The name of the field to check the type of. - * @param type The type to check for. - * @return A new [BooleanExpression] that evaluates to true if the expression's result is of the - * given type, false otherwise. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression isType(java.lang.String fieldName, java.lang.String type) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the length of a string, array, map, vector, or blob - * expression. - * - * ```kotlin - * // Get the length of the 'value' field where the value type can be any of a string, array, map, vector or blob. - * length(field("value")) - * ``` - * - * @param expr The expression representing the string. - * @return A new [Expression] representing the length operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression length(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the length of a string, array, map, vector, or blob - * field. - * - * ```kotlin - * // Get the length of the 'value' field where the value type can be any of a string, array, map, vector or blob. - * charLength("value") - * ``` - * - * @param fieldName The name of the field containing the string. - * @return A new [Expression] representing the length operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression length(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the character length of a string expression in UTF8. - * - * ```kotlin - * // Get the character length of the 'name' field in UTF-8. - * charLength("name") - * ``` - * - * @param expr The expression representing the string. - * @return A new [Expression] representing the charLength operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression charLength(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the character length of a string field in UTF8. - * - * ```kotlin - * // Get the character length of the 'name' field in UTF-8. - * charLength("name") - * ``` - * - * @param fieldName The name of the field containing the string. - * @return A new [Expression] representing the charLength operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression charLength(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the length of a string in UTF-8 bytes, or just the - * length of a Blob. - * - * ```kotlin - * // Calculate the length of the 'myString' field in bytes. - * byteLength("myString") - * ``` - * - * @param value The expression representing the string. - * @return A new [Expression] representing the length of the string in bytes. - */ - -public static final com.google.firebase.firestore.pipeline.Expression byteLength(com.google.firebase.firestore.pipeline.Expression value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the length of a string represented by a field in UTF-8 - * bytes, or just the length of a Blob. - * - * ```kotlin - * // Calculate the length of the 'myString' field in bytes. - * byteLength("myString") - * ``` - * - * @param fieldName The name of the field containing the string. - * @return A new [Expression] representing the length of the string in bytes. - */ - -public static final com.google.firebase.firestore.pipeline.Expression byteLength(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that performs a case-sensitive wildcard string comparison. - * - * ```kotlin - * // Check if the 'title' field contains the string "guide" - * like(field("title"), "%guide%") - * ``` - * - * @param stringExpression The expression representing the string to perform the comparison on. - * @param pattern The pattern to search for. You can use "%" as a wildcard character. - * @return A new [BooleanExpression] representing the like operation. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression like(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that splits a string or blob by a delimiter. - * - * ```kotlin - * // Split the 'tags' field by a comma - * split(field("tags"), field("delimiter")) - * ``` - * - * @param value The expression evaluating to a string or blob to be split. - * @param delimiter The delimiter to split by. Must be of the same type as `value`. - * @return A new [Expression] that evaluates to an array of segments. - */ - -public static final com.google.firebase.firestore.pipeline.Expression split(com.google.firebase.firestore.pipeline.Expression value, com.google.firebase.firestore.pipeline.Expression delimiter) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that splits a string or blob by a string delimiter. - * - * ```kotlin - * // Split the 'tags' field by a comma - * split(field("tags"), ",") - * ``` - * - * @param value The expression evaluating to a string or blob to be split. - * @param delimiter The string delimiter to split by. - * @return A new [Expression] that evaluates to an array of segments. - */ - -public static final com.google.firebase.firestore.pipeline.Expression split(com.google.firebase.firestore.pipeline.Expression value, java.lang.String delimiter) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that splits a blob by a blob delimiter. - * - * ```kotlin - * // Split the 'data' field by a delimiter - * split(field("data"), Blob.fromBytes(byteArrayOf(0x0a))) - * ``` - * - * @param value The expression evaluating to a blob to be split. - * @param delimiter The blob delimiter to split by. - * @return A new [Expression] that evaluates to an array of segments. - */ - -public static final com.google.firebase.firestore.pipeline.Expression split(com.google.firebase.firestore.pipeline.Expression value, com.google.firebase.firestore.Blob delimiter) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that splits a string or blob field by a delimiter. - * - * ```kotlin - * // Split the 'tags' field by the value of the 'delimiter' field - * split("tags", field("delimiter")) - * ``` - * - * @param fieldName The name of the field containing the string or blob to be split. - * @param delimiter The delimiter to split by. - * @return A new [Expression] that evaluates to an array of segments. - */ - -public static final com.google.firebase.firestore.pipeline.Expression split(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression delimiter) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that splits a string or blob field by a string delimiter. - * - * ```kotlin - * // Split the 'tags' field by a comma - * split("tags", ",") - * ``` - * - * @param fieldName The name of the field containing the string or blob to be split. - * @param delimiter The string delimiter to split by. - * @return A new [Expression] that evaluates to an array of segments. - */ - -public static final com.google.firebase.firestore.pipeline.Expression split(java.lang.String fieldName, java.lang.String delimiter) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that splits a blob field by a blob delimiter. - * - * ```kotlin - * // Split the 'data' field by a delimiter - * split("data", Blob.fromBytes(byteArrayOf(0x0a))) - * ``` - * - * @param fieldName The name of the field containing the blob to be split. - * @param delimiter The blob delimiter to split by. - * @return A new [Expression] that evaluates to an array of segments. - */ - -public static final com.google.firebase.firestore.pipeline.Expression split(java.lang.String fieldName, com.google.firebase.firestore.Blob delimiter) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that joins the elements of an array into a string. - * - * ```kotlin - * // Join the elements of the 'tags' field with a comma and space. - * join(field("tags"), ", ") - * ``` - * - * @param arrayExpression The expression that evaluates to an array. - * @param delimiter The string to use as a delimiter. - * @return A new [Expression] representing the join operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression join(com.google.firebase.firestore.pipeline.Expression arrayExpression, java.lang.String delimiter) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that joins the elements of an array into a string. - * - * ```kotlin - * // Join the elements of the 'tags' field with the delimiter from the 'separator' field. - * join(field("tags"), field("separator")) - * ``` - * - * @param arrayExpression The expression that evaluates to an array. - * @param delimiterExpression The expression that evaluates to the delimiter string. - * @return A new [Expression] representing the join operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression join(com.google.firebase.firestore.pipeline.Expression arrayExpression, com.google.firebase.firestore.pipeline.Expression delimiterExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that joins the elements of an array field into a string. - * - * ```kotlin - * // Join the elements of the 'tags' field with a comma and space. - * join("tags", ", ") - * ``` - * - * @param arrayFieldName The name of the field containing the array. - * @param delimiter The string to use as a delimiter. - * @return A new [Expression] representing the join operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression join(java.lang.String arrayFieldName, java.lang.String delimiter) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that joins the elements of an array field into a string. - * - * ```kotlin - * // Join the elements of the 'tags' field with the delimiter from the 'separator' field. - * join("tags", field("separator")) - * ``` - * - * @param arrayFieldName The name of the field containing the array. - * @param delimiterExpression The expression that evaluates to the delimiter string. - * @return A new [Expression] representing the join operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression join(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression delimiterExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that performs a case-sensitive wildcard string comparison. - * - * ```kotlin - * // Check if the 'title' field contains the string "guide" - * like(field("title"), "%guide%") - * ``` - * - * @param stringExpression The expression representing the string to perform the comparison on. - * @param pattern The pattern to search for. You can use "%" as a wildcard character. - * @return A new [BooleanExpression] representing the like operation. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression like(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that performs a case-sensitive wildcard string comparison against a - * field. - * - * ```kotlin - * // Check if the 'title' field contains the string "guide" - * like("title", "%guide%") - * ``` - * - * @param fieldName The name of the field containing the string. - * @param pattern The pattern to search for. You can use "%" as a wildcard character. - * @return A new [BooleanExpression] representing the like comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression like(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that performs a case-sensitive wildcard string comparison against a - * field. - * - * ```kotlin - * // Check if the 'title' field contains the string "guide" - * like("title", "%guide%") - * ``` - * - * @param fieldName The name of the field containing the string. - * @param pattern The pattern to search for. You can use "%" as a wildcard character. - * @return A new [BooleanExpression] representing the like comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression like(java.lang.String fieldName, java.lang.String pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a pseudo-random number of type double in the range of [0, - * 1), inclusive of 0 and exclusive of 1. - * - * ```kotlin - * // Get a random number. - * rand() - * ``` - * - * @return A new [Expression] representing the random number operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression rand() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string expression contains a specified regular - * expression as a substring. - * - * ```kotlin - * // Check if the 'description' field contains "example" (case-insensitive) - * regexContains(field("description"), "(?i)example") - * ``` - * - * @param stringExpression The expression representing the string to perform the comparison on. - * @param pattern The regular expression to use for the search. - * @return A new [BooleanExpression] representing the contains regular expression comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression regexContains(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string expression contains a specified regular - * expression as a substring. - * - * ```kotlin - * // Check if the 'description' field contains "example" (case-insensitive) - * regexContains(field("description"), "(?i)example") - * ``` - * - * @param stringExpression The expression representing the string to perform the comparison on. - * @param pattern The regular expression to use for the search. - * @return A new [BooleanExpression] representing the contains regular expression comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression regexContains(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string field contains a specified regular expression - * as a substring. - * - * ```kotlin - * // Check if the 'description' field contains the regex from the 'pattern' field. - * regexContains("description", field("pattern")) - * ``` - * - * @param fieldName The name of the field containing the string. - * @param pattern The regular expression to use for the search. - * @return A new [BooleanExpression] representing the contains regular expression comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression regexContains(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string field contains a specified regular expression - * as a substring. - * - * ```kotlin - * // Check if the 'description' field contains "example" (case-insensitive) - * regexContains("description", "(?i)example") - * ``` - * - * @param fieldName The name of the field containing the string. - * @param pattern The regular expression to use for the search. - * @return A new [BooleanExpression] representing the contains regular expression comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression regexContains(java.lang.String fieldName, java.lang.String pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first substring of a string expression that matches a - * specified regular expression. - * - * This expression uses the [RE2](https://github.com/google/re2/wiki/Syntax) regular expression - * syntax. - * - * ```kotlin - * // Extract a substring based on a dynamic pattern field - * regexFind(field("email"), field("pattern")) - * ``` - * - * @param stringExpression The expression representing the string to search. - * @param pattern The regular expression to search for. - * @return A new [Expression] representing the regular expression find function. - */ - -public static final com.google.firebase.firestore.pipeline.Expression regexFind(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first substring of a string expression that matches a - * specified regular expression. - * - * This expression uses the [RE2](https://github.com/google/re2/wiki/Syntax) regular expression - * syntax. - * - * ```kotlin - * // Extract the domain from a lower-cased email address - * regexFind(field("email"), "@[A-Za-z0-9.-]+") - * ``` - * - * @param stringExpression The expression representing the string to search. - * @param pattern The regular expression to search for. - * @return A new [Expression] representing the regular expression find function. - */ - -public static final com.google.firebase.firestore.pipeline.Expression regexFind(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first substring of a string field that matches a - * specified regular expression. - * - * This expression uses the [RE2](https://github.com/google/re2/wiki/Syntax) regular expression - * syntax. - * - * ```kotlin - * // Extract a substring from 'email' based on a pattern stored in another field - * regexFind("email", field("pattern")) - * ``` - * - * @param fieldName The name of the field containing the string to search. - * @param pattern The regular expression to search for. - * @return A new [Expression] representing the regular expression find function. - */ - -public static final com.google.firebase.firestore.pipeline.Expression regexFind(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first substring of a string field that matches a - * specified regular expression. - * - * This expression uses the [RE2](https://github.com/google/re2/wiki/Syntax) regular expression - * syntax. - * - * ```kotlin - * // Extract the domain name from an email field - * regexFind("email", "@[A-Za-z0-9.-]+") - * ``` - * - * @param fieldName The name of the field containing the string to search. - * @param pattern The regular expression to search for. - * @return A new [Expression] representing the regular expression find function. - */ - -public static final com.google.firebase.firestore.pipeline.Expression regexFind(java.lang.String fieldName, java.lang.String pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that evaluates to a list of all substrings in a string expression that - * match a specified regular expression. - * - * This expression uses the [RE2](https://github.com/google/re2/wiki/Syntax) regular expression - * syntax. - * - * ```kotlin - * // Extract all matches based on a dynamic pattern expression - * regexFindAll(field("comment"), field("pattern")) - * ``` - * - * @param stringExpression The expression representing the string to search. - * @param pattern The regular expression to search for. - * @return A new [Expression] that evaluates to a list of matched substrings. - */ - -public static final com.google.firebase.firestore.pipeline.Expression regexFindAll(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that evaluates to a list of all substrings in a string expression that - * match a specified regular expression. - * - * This expression uses the [RE2](https://github.com/google/re2/wiki/Syntax) regular expression - * syntax. - * - * ```kotlin - * // Extract all mentions from a lower-cased comment - * regexFindAll(field("comment"), "@[A-Za-z0-9_]+") - * ``` - * - * @param stringExpression The expression representing the string to search. - * @param pattern The regular expression to search for. - * @return A new [Expression] that evaluates to a list of matched substrings. - */ - -public static final com.google.firebase.firestore.pipeline.Expression regexFindAll(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that evaluates to a list of all substrings in a string field that match - * a specified regular expression. - * - * This expression uses the [RE2](https://github.com/google/re2/wiki/Syntax) regular expression - * syntax. - * - * ```kotlin - * // Extract all matches from 'content' based on a pattern stored in another field - * regexFindAll("content", field("pattern")) - * ``` - * - * @param fieldName The name of the field containing the string to search. - * @param pattern The regular expression to search for. - * @return A new [Expression] that evaluates to a list of matched substrings. - */ - -public static final com.google.firebase.firestore.pipeline.Expression regexFindAll(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that evaluates to a list of all substrings in a string field that match - * a specified regular expression. - * - * This expression uses the [RE2](https://github.com/google/re2/wiki/Syntax) regular expression - * syntax. - * - * ```kotlin - * // Extract all hashtags from a post content field - * regexFindAll("content", "#[A-Za-z0-9_]+") - * ``` - * - * @param fieldName The name of the field containing the string to search. - * @param pattern The regular expression to search for. - * @return A new [Expression] that evaluates to a list of matched substrings. - */ - -public static final com.google.firebase.firestore.pipeline.Expression regexFindAll(java.lang.String fieldName, java.lang.String pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string field matches a specified regular expression. - * - * ```kotlin - * // Check if the 'email' field matches a valid email pattern - * regexMatch(field("email"), "[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}") - * ``` - * - * @param stringExpression The expression representing the string to match against. - * @param pattern The regular expression to use for the match. - * @return A new [BooleanExpression] representing the regular expression match comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression regexMatch(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string field matches a specified regular expression. - * - * ```kotlin - * // Check if the 'email' field matches a valid email pattern - * regexMatch(field("email"), "[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}") - * ``` - * - * @param stringExpression The expression representing the string to match against. - * @param pattern The regular expression to use for the match. - * @return A new [BooleanExpression] representing the regular expression match comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression regexMatch(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string field matches a specified regular expression. - * - * ```kotlin - * // Check if the 'email' field matches the regex from the 'pattern' field. - * regexMatch("email", field("pattern")) - * ``` - * - * @param fieldName The name of the field containing the string. - * @param pattern The regular expression to use for the match. - * @return A new [BooleanExpression] representing the regular expression match comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression regexMatch(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string field matches a specified regular expression. - * - * ```kotlin - * // Check if the 'email' field matches a valid email pattern - * regexMatch("email", "[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}") - * ``` - * - * @param fieldName The name of the field containing the string. - * @param pattern The regular expression to use for the match. - * @return A new [BooleanExpression] representing the regular expression match comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression regexMatch(java.lang.String fieldName, java.lang.String pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the largest value between multiple input expressions or - * literal values. Based on Firestore's value type ordering. - * - * ```kotlin - * // Returns the larger value between the 'timestamp' field and the current timestamp. - * logicalMaximum(field("timestamp"), currentTimestamp()) - * ``` - * - * @param expr The first operand expression. - * @param others Optional additional expressions or literals. - * @return A new [Expression] representing the logical maximum operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression logicalMaximum(com.google.firebase.firestore.pipeline.Expression expr, java.lang.Object... others) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the largest value between multiple input expressions or - * literal values. Based on Firestore's value type ordering. - * - * ```kotlin - * // Returns the larger value between the 'timestamp' field and the current timestamp. - * logicalMaximum("timestamp", currentTimestamp()) - * ``` - * - * @param fieldName The first operand field name. - * @param others Optional additional expressions or literals. - * @return A new [Expression] representing the logical maximum operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression logicalMaximum(java.lang.String fieldName, java.lang.Object... others) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the smallest value between multiple input expressions or - * literal values. Based on Firestore's value type ordering. - * - * ```kotlin - * // Returns the smaller value between the 'timestamp' field and the current timestamp. - * logicalMinimum(field("timestamp"), currentTimestamp()) - * ``` - * - * @param expr The first operand expression. - * @param others Optional additional expressions or literals. - * @return A new [Expression] representing the logical minimum operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression logicalMinimum(com.google.firebase.firestore.pipeline.Expression expr, java.lang.Object... others) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the smallest value between multiple input expressions or - * literal values. Based on Firestore's value type ordering. - * - * ```kotlin - * // Returns the smaller value between the 'timestamp' field and the current timestamp. - * logicalMinimum("timestamp", currentTimestamp()) - * ``` - * - * @param fieldName The first operand field name. - * @param others Optional additional expressions or literals. - * @return A new [Expression] representing the logical minimum operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression logicalMinimum(java.lang.String fieldName, java.lang.Object... others) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that reverses a string. - * - * ```kotlin - * // Reverse the value of the 'myString' field. - * reverse(field("myString")) - * ``` - * - * @param stringExpression An expression evaluating to a string value, which will be reversed. - * @return A new [Expression] representing the reversed string. - */ - -public static final com.google.firebase.firestore.pipeline.Expression reverse(com.google.firebase.firestore.pipeline.Expression stringExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that reverses a string value from the specified field. - * - * ```kotlin - * // Reverse the value of the 'myString' field. - * reverse("myString") - * ``` - * - * @param fieldName The name of the field that contains the string to reverse. - * @return A new [Expression] representing the reversed string. - */ - -public static final com.google.firebase.firestore.pipeline.Expression reverse(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string expression contains a specified substring. - * - * ```kotlin - * // Check if the 'description' field contains the value of the 'keyword' field. - * stringContains(field("description"), field("keyword")) - * ``` - * - * @param stringExpression The expression representing the string to perform the comparison on. - * @param substring The expression representing the substring to search for. - * @return A new [BooleanExpression] representing the contains comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression stringContains(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression substring) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string expression contains a specified substring. - * - * ```kotlin - * // Check if the 'description' field contains "example". - * stringContains(field("description"), "example") - * ``` - * - * @param stringExpression The expression representing the string to perform the comparison on. - * @param substring The substring to search for. - * @return A new [BooleanExpression] representing the contains comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression stringContains(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String substring) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string field contains a specified substring. - * - * ```kotlin - * // Check if the 'description' field contains the value of the 'keyword' field. - * stringContains("description", field("keyword")) - * ``` - * - * @param fieldName The name of the field to perform the comparison on. - * @param substring The expression representing the substring to search for. - * @return A new [BooleanExpression] representing the contains comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression stringContains(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression substring) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string field contains a specified substring. - * - * ```kotlin - * // Check if the 'description' field contains "example". - * stringContains("description", "example") - * ``` - * - * @param fieldName The name of the field to perform the comparison on. - * @param substring The substring to search for. - * @return A new [BooleanExpression] representing the contains comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression stringContains(java.lang.String fieldName, java.lang.String substring) { throw new RuntimeException("Stub!"); } - -/** - * ```kotlin - * // Check if the 'fullName' field starts with the value of the 'firstName' field - * startsWith(field("fullName"), field("firstName")) - * ``` - * - * @param stringExpr The expression to check. - * @param prefix The prefix string expression to check for. - * @return A new [BooleanExpression] representing the 'starts with' comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression startsWith(com.google.firebase.firestore.pipeline.Expression stringExpr, com.google.firebase.firestore.pipeline.Expression prefix) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string expression starts with a given [prefix]. - * - * ```kotlin - * // Check if the 'name' field starts with "Mr." - * startsWith(field("name"), "Mr.") - * ``` - * - * @param stringExpr The expression to check. - * @param prefix The prefix string to check for. - * @return A new [BooleanExpression] representing the 'starts with' comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression startsWith(com.google.firebase.firestore.pipeline.Expression stringExpr, java.lang.String prefix) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string expression starts with a given [prefix]. - * - * ```kotlin - * // Check if the 'fullName' field starts with the value of the 'firstName' field - * startsWith("fullName", field("firstName")) - * ``` - * - * @param fieldName The name of field that contains a string to check. - * @param prefix The prefix string expression to check for. - * @return A new [BooleanExpression] representing the 'starts with' comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression startsWith(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression prefix) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string expression starts with a given [prefix]. - * - * ```kotlin - * // Check if the 'name' field starts with "Mr." - * startsWith("name", "Mr.") - * ``` - * - * @param fieldName The name of field that contains a string to check. - * @param prefix The prefix string to check for. - * @return A new [BooleanExpression] representing the 'starts with' comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression startsWith(java.lang.String fieldName, java.lang.String prefix) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string expression ends with a given [suffix]. - * - * ```kotlin - * // Check if the 'url' field ends with the value of the 'extension' field - * endsWith(field("url"), field("extension")) - * ``` - * - * @param stringExpr The expression to check. - * @param suffix The suffix string expression to check for. - * @return A new [BooleanExpression] representing the 'ends with' comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression endsWith(com.google.firebase.firestore.pipeline.Expression stringExpr, com.google.firebase.firestore.pipeline.Expression suffix) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string expression ends with a given [suffix]. - * - * ```kotlin - * // Check if the 'filename' field ends with ".txt" - * endsWith(field("filename"), ".txt") - * ``` - * - * @param stringExpr The expression to check. - * @param suffix The suffix string to check for. - * @return A new [BooleanExpression] representing the 'ends with' comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression endsWith(com.google.firebase.firestore.pipeline.Expression stringExpr, java.lang.String suffix) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string expression ends with a given [suffix]. - * - * ```kotlin - * // Check if the 'url' field ends with the value of the 'extension' field - * endsWith("url", field("extension")) - * ``` - * - * @param fieldName The name of field that contains a string to check. - * @param suffix The suffix string expression to check for. - * @return A new [BooleanExpression] representing the 'ends with' comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression endsWith(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression suffix) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string expression ends with a given [suffix]. - * - * ```kotlin - * // Check if the 'filename' field ends with ".txt" - * endsWith("filename", ".txt") - * ``` - * - * @param fieldName The name of field that contains a string to check. - * @param suffix The suffix string to check for. - * @return A new [BooleanExpression] representing the 'ends with' comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression endsWith(java.lang.String fieldName, java.lang.String suffix) { throw new RuntimeException("Stub!"); } - -/** - * Reverses the given string expression. - * - * ```kotlin - * // Reverse the value of the 'myString' field. - * stringReverse(field("myString")) - * ``` - * - * @param str The string expression to reverse. - * @return A new [Expression] representing the stringReverse operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression stringReverse(com.google.firebase.firestore.pipeline.Expression str) { throw new RuntimeException("Stub!"); } - -/** - * Reverses the given string field. - * - * ```kotlin - * // Reverse the value of the 'myString' field. - * stringReverse("myString") - * ``` - * - * @param fieldName The name of field that contains the string to reverse. - * @return A new [Expression] representing the stringReverse operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression stringReverse(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a substring of the given string. - * - * ```kotlin - * // Get a substring of the 'message' field starting at index 5 with length 10. - * substring(field("message"), constant(5), constant(10)) - * ``` - * - * @param stringExpression The expression representing the string to get a substring from. - * @param index The starting index of the substring. - * @param length The length of the substring. - * @return A new [Expression] representing the substring. - */ - -public static final com.google.firebase.firestore.pipeline.Expression substring(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression index, com.google.firebase.firestore.pipeline.Expression length) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a substring of the given string. - * - * ```kotlin - * // Get a substring of the 'message' field starting at index 5 with length 10. - * substring("message", 5, 10) - * ``` - * - * @param fieldName The name of the field containing the string to get a substring from. - * @param index The starting index of the substring. - * @param length The length of the substring. - * @return A new [Expression] representing the substring. - */ - -public static final com.google.firebase.firestore.pipeline.Expression substring(java.lang.String fieldName, int index, int length) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that converts a string expression to lowercase. - * - * ```kotlin - * // Convert the 'name' field to lowercase - * toLower(field("name")) - * ``` - * - * @param stringExpression The expression representing the string to convert to lowercase. - * @return A new [Expression] representing the lowercase string. - */ - -public static final com.google.firebase.firestore.pipeline.Expression toLower(com.google.firebase.firestore.pipeline.Expression stringExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that converts a string field to lowercase. - * - * ```kotlin - * // Convert the 'name' field to lowercase - * toLower("name") - * ``` - * - * @param fieldName The name of the field containing the string to convert to lowercase. - * @return A new [Expression] representing the lowercase string. - */ - -public static final com.google.firebase.firestore.pipeline.Expression toLower(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that converts a string expression to uppercase. - * - * ```kotlin - * // Convert the 'title' field to uppercase - * toUpper(field("title")) - * ``` - * - * @param stringExpression The expression representing the string to convert to uppercase. - * @return A new [Expression] representing the uppercase string. - */ - -public static final com.google.firebase.firestore.pipeline.Expression toUpper(com.google.firebase.firestore.pipeline.Expression stringExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that converts a string field to uppercase. - * - * ```kotlin - * // Convert the 'title' field to uppercase - * toUpper("title") - * ``` - * - * @param fieldName The name of the field containing the string to convert to uppercase. - * @return A new [Expression] representing the uppercase string. - */ - -public static final com.google.firebase.firestore.pipeline.Expression toUpper(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes leading and trailing whitespace from a string expression. - * - * ```kotlin - * // Trim whitespace from the 'userInput' field - * trim(field("userInput")) - * ``` - * - * @param stringExpression The expression representing the string to trim. - * @return A new [Expression] representing the trimmed string. - */ - -public static final com.google.firebase.firestore.pipeline.Expression trim(com.google.firebase.firestore.pipeline.Expression stringExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes leading and trailing whitespace from a string field. - * - * ```kotlin - * // Trim whitespace from the 'userInput' field - * trim("userInput") - * ``` - * - * @param fieldName The name of the field containing the string to trim. - * @return A new [Expression] representing the trimmed string. - */ - -public static final com.google.firebase.firestore.pipeline.Expression trim(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes a set of leading and trailing values from an expression. - * - * Note: The values to trim are treated as a **set**, not a substring. - * - * ```kotlin - * // Trim specified characters from the 'userInput' field - * trimValue(field("userInput"), field("valueToTrim")) - * ``` - * - * @param stringExpression The expression representing the string to trim. - * @param valueToTrim The expression evaluated to either a string or a blob. This parameter is - * treated as a set of characters or bytes that will be matched against the input from both - * ends. - * @return A new [Expression] representing the trimmed string or bytes. - */ - -public static final com.google.firebase.firestore.pipeline.Expression trimValue(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression valueToTrim) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes a set of leading and trailing values from a string field. - * - * Note: The values to trim are treated as a **set**, not a substring. - * - * ```kotlin - * // Trim all '-', and '_' characters from the beginning and the end of 'userInput' field - * trimValue("userInput", "-_") - * ``` - * - * @param fieldName The name of the field containing the string to trim. - * @param valueToTrim This parameter is treated as a set of characters or bytes that will be - * matched against the input from both ends. - * @return A new [Expression] representing the trimmed string. - */ - -public static final com.google.firebase.firestore.pipeline.Expression trimValue(java.lang.String fieldName, java.lang.String valueToTrim) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes leading whitespace from a string expression. - * - * ```kotlin - * // Trim leading whitespace from the 'text' field. - * ltrim(field("text")) - * ``` - * - * @param stringExpression The expression representing the string to trim. - * @return A new [Expression] representing the ltrim operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression ltrim(com.google.firebase.firestore.pipeline.Expression stringExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes leading whitespace from a string field. - * - * ```kotlin - * // Trim leading whitespace from the 'text' field. - * ltrim("text") - * ``` - * - * @param fieldName The name of the field containing the string to trim. - * @return A new [Expression] representing the ltrim operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression ltrim(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes a set of leading values from a string expression. - * - * Note: The values to trim are treated as a **set**, not a substring. - * - * ```kotlin - * // Trim all leading '-' and '_' characters from the 'text' field. - * ltrimValue(field("text"), "-_") - * ``` - * - * @param stringExpression The expression representing the string to trim. - * @param valuesToTrim The set of values to remove. - * @return A new [Expression] representing the ltrim operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression ltrimValue(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String valuesToTrim) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes a set of leading values from a string expression. - * - * Note: The values to trim are treated as a **set**, not a substring. - * - * ```kotlin - * // Trim leading characters defined by the 'chars' field from the 'text' field. - * ltrimValue(field("text"), field("chars")) - * ``` - * - * @param stringExpression The expression representing the string to trim. - * @param valuesToTrim The expression representing the set of values to remove. - * @return A new [Expression] representing the ltrim operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression ltrimValue(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression valuesToTrim) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes specified leading values from a string field. - * - * Note: The values to trim are treated as a **set**, not a substring. - * - * ```kotlin - * // Trim all leading '-' and '_' characters from the 'text' field. - * ltrimValue("text", "-_") - * ``` - * - * @param fieldName The name of the field containing the string to trim. - * @param valuesToTrim The set of values to remove. - * @return A new [Expression] representing the ltrim operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression ltrimValue(java.lang.String fieldName, java.lang.String valuesToTrim) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes specified leading values from a string field. - * - * Note: The values to trim are treated as a **set**, not a substring. - * - * ```kotlin - * // Trim leading characters defined by the 'chars' field from the 'text' field. - * ltrimValue("text", field("chars")) - * ``` - * - * @param fieldName The name of the field containing the string to trim. - * @param valuesToTrim The expression representing the set of values to remove. - * @return A new [Expression] representing the ltrim operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression ltrimValue(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression valuesToTrim) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes trailing whitespace from a string expression. - * - * ```kotlin - * // Trim trailing whitespace from the 'text' field. - * rtrim(field("text")) - * ``` - * - * @param stringExpression The expression representing the string to trim. - * @return A new [Expression] representing the rtrim operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression rtrim(com.google.firebase.firestore.pipeline.Expression stringExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes trailing whitespace from a string field. - * - * ```kotlin - * // Trim trailing whitespace from the 'text' field. - * rtrim("text") - * ``` - * - * @param fieldName The name of the field containing the string to trim. - * @return A new [Expression] representing the rtrim operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression rtrim(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes a set of trailing values from a string expression. - * - * Note: The values to trim are treated as a **set**, not a substring. - * - * ```kotlin - * // Trim all trailing '-' and '_' characters from the 'text' field. - * rtrimValue(field("text"), "-_") - * ``` - * - * @param stringExpression The expression representing the string to trim. - * @param valuesToTrim The set of values to remove. - * @return A new [Expression] representing the rtrim operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression rtrimValue(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String valuesToTrim) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes a set of trailing values from a string expression. - * - * Note: The values to trim are treated as a **set**, not a substring. - * - * ```kotlin - * // Trim trailing characters defined by the 'chars' field from the 'text' field. - * rtrimValue(field("text"), field("chars")) - * ``` - * - * @param stringExpression The expression representing the string to trim. - * @param valuesToTrim The expression representing the set of values to remove. - * @return A new [Expression] representing the rtrim operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression rtrimValue(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression valuesToTrim) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes a set of trailing values from a string field. - * - * Note: The values to trim are treated as a **set**, not a substring. - * - * ```kotlin - * // Trim all trailing '-' and '_' characters from the 'text' field. - * rtrimValue("text", "-_") - * ``` - * - * @param fieldName The name of the field containing the string to trim. - * @param valuesToTrim The set of values to remove. - * @return A new [Expression] representing the rtrim operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression rtrimValue(java.lang.String fieldName, java.lang.String valuesToTrim) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes a set of trailing values from a string field. - * - * Note: The values to trim are treated as a **set**, not a substring. - * - * ```kotlin - * // Trim trailing characters defined by the 'chars' field from the 'text' field. - * rtrimValue("text", field("chars")) - * ``` - * - * @param fieldName The name of the field containing the string to trim. - * @param valuesToTrim The expression representing the set of values to remove. - * @return A new [Expression] representing the rtrim operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression rtrimValue(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression valuesToTrim) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that repeats a string expression a given number of times. - * - * ```kotlin - * // Repeat the 'name' field 3 times. - * stringRepeat(field("name"), 3) - * ``` - * - * @param stringExpression The expression representing the string to repeat. - * @param count The number of times to repeat the string. - * @return A new [Expression] representing the stringRepeat operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression stringRepeat(com.google.firebase.firestore.pipeline.Expression stringExpression, int count) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that repeats a string expression a given number of times. - * - * ```kotlin - * // Repeat the 'name' field the number of times specified in the 'count' field. - * stringRepeat(field("name"), field("count")) - * ``` - * - * @param stringExpression The expression representing the string to repeat. - * @param count The expression representing the number of times to repeat the string. - * @return A new [Expression] representing the stringRepeat operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression stringRepeat(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression count) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that repeats a string field a given number of times. - * - * ```kotlin - * // Repeat the 'name' field 3 times. - * stringRepeat("name", 3) - * ``` - * - * @param fieldName The name of the field containing the string to repeat. - * @param count The number of times to repeat the string. - * @return A new [Expression] representing the stringRepeat operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression stringRepeat(java.lang.String fieldName, int count) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that repeats a string field a given number of times. - * - * ```kotlin - * // Repeat the 'name' field the number of times specified in the 'count' field. - * stringRepeat("name", field("count")) - * ``` - * - * @param fieldName The name of the field containing the string to repeat. - * @param count The expression representing the number of times to repeat the string. - * @return A new [Expression] representing the stringRepeat operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression stringRepeat(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression count) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that replaces all occurrences of a substring with another string. - * - * ```kotlin - * // Replace all occurrences of the 'old' field with the 'new' field in 'text'. - * stringReplaceAll(field("text"), field("old"), field("new")) - * ``` - * - * @param stringExpression The expression representing the original string. - * @param oldValue The expression representing the substring to replace. - * @param newValue The expression representing the replacement string. - * @return A new [Expression] representing the stringReplaceAll operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression stringReplaceAll(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression oldValue, com.google.firebase.firestore.pipeline.Expression newValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that replaces all occurrences of a substring with another string. - * - * ```kotlin - * // Replace all occurrences of "cat" with "dog" in the 'text' field. - * stringReplaceAll(field("text"), "cat", "dog") - * ``` - * - * @param stringExpression The expression representing the original string. - * @param oldValue The substring to replace. - * @param newValue The replacement string. - * @return A new [Expression] representing the stringReplaceAll operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression stringReplaceAll(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String oldValue, java.lang.String newValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that replaces all occurrences of a substring with another string in a - * field. - * - * ```kotlin - * // Replace all occurrences of the 'old' field with the 'new' field in 'text'. - * stringReplaceAll("text", field("old"), field("new")) - * ``` - * - * @param fieldName The name of the field containing the original string. - * @param oldValue The expression representing the substring to replace. - * @param newValue The expression representing the replacement string. - * @return A new [Expression] representing the stringReplaceAll operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression stringReplaceAll(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression oldValue, com.google.firebase.firestore.pipeline.Expression newValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that replaces all occurrences of a substring with another string in a - * field. - * - * ```kotlin - * // Replace all occurrences of "cat" with "dog" in the 'text' field. - * stringReplaceAll("text", "cat", "dog") - * ``` - * - * @param fieldName The name of the field containing the original string. - * @param oldValue The substring to replace. - * @param newValue The replacement string. - * @return A new [Expression] representing the stringReplaceAll operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression stringReplaceAll(java.lang.String fieldName, java.lang.String oldValue, java.lang.String newValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that replaces the first occurrence of a substring with another string. - * - * ```kotlin - * // Replace the first occurrence of the 'old' field with the 'new' field in 'text'. - * stringReplaceOne(field("text"), field("old"), field("new")) - * ``` - * - * @param stringExpression The expression representing the original string. - * @param oldValue The expression representing the substring to replace. - * @param newValue The expression representing the replacement string. - * @return A new [Expression] representing the stringReplaceOne operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression stringReplaceOne(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression oldValue, com.google.firebase.firestore.pipeline.Expression newValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that replaces the first occurrence of a substring with another string. - * - * ```kotlin - * // Replace the first occurrence of "cat" with "dog" in the 'text' field. - * stringReplaceOne(field("text"), "cat", "dog") - * ``` - * - * @param stringExpression The expression representing the original string. - * @param oldValue The substring to replace. - * @param newValue The replacement string. - * @return A new [Expression] representing the stringReplaceOne operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression stringReplaceOne(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String oldValue, java.lang.String newValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that replaces the first occurrence of a substring with another string - * in a field. - * - * ```kotlin - * // Replace the first occurrence of the 'old' field with the 'new' field in 'text'. - * stringReplaceOne("text", field("old"), field("new")) - * ``` - * - * @param fieldName The name of the field containing the original string. - * @param oldValue The expression representing the substring to replace. - * @param newValue The expression representing the replacement string. - * @return A new [Expression] representing the stringReplaceOne operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression stringReplaceOne(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression oldValue, com.google.firebase.firestore.pipeline.Expression newValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that replaces the first occurrence of a substring with another string - * in a field. - * - * ```kotlin - * // Replace the first occurrence of "cat" with "dog" in the 'text' field. - * stringReplaceOne("text", "cat", "dog") - * ``` - * - * @param fieldName The name of the field containing the original string. - * @param oldValue The substring to replace. - * @param newValue The replacement string. - * @return A new [Expression] representing the stringReplaceOne operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression stringReplaceOne(java.lang.String fieldName, java.lang.String oldValue, java.lang.String newValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the 0-based index of the first occurrence of the specified - * substring. - * - * ```kotlin - * // Get the index of the 'search' field within the 'text' field. - * stringIndexOf(field("text"), field("search")) - * ``` - * - * @param stringExpression The expression representing the string to search within. - * @param substring The expression representing the substring to search for. - * @return A new [Expression] representing the stringIndexOf operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression stringIndexOf(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression substring) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the 0-based index of the first occurrence of the specified - * substring. - * - * ```kotlin - * // Get the index of "world" within the 'text' field. - * stringIndexOf(field("text"), "world") - * ``` - * - * @param stringExpression The expression representing the string to search within. - * @param substring The substring to search for. - * @return A new [Expression] representing the stringIndexOf operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression stringIndexOf(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String substring) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the 0-based index of the first occurrence of the specified - * substring in a field. - * - * ```kotlin - * // Get the index of the 'search' field within the 'text' field. - * stringIndexOf("text", field("search")) - * ``` - * - * @param fieldName The name of the field containing the string to search within. - * @param substring The expression representing the substring to search for. - * @return A new [Expression] representing the stringIndexOf operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression stringIndexOf(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression substring) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the 0-based index of the first occurrence of the specified - * substring in a field. - * - * ```kotlin - * // Get the index of "world" within the 'text' field. - * stringIndexOf("text", "world") - * ``` - * - * @param fieldName The name of the field containing the string to search within. - * @param substring The substring to search for. - * @return A new [Expression] representing the stringIndexOf operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression stringIndexOf(java.lang.String fieldName, java.lang.String substring) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that concatenates string expressions together. - * - * ```kotlin - * // Combine the 'firstName', " ", and 'lastName' fields into a single string - * stringConcat(field("firstName"), constant(" "), field("lastName")) - * ``` - * - * @param firstString The expression representing the initial string value. - * @param otherStrings Optional additional string expressions to concatenate. - * @return A new [Expression] representing the concatenated string. - */ - -public static final com.google.firebase.firestore.pipeline.Expression stringConcat(com.google.firebase.firestore.pipeline.Expression firstString, com.google.firebase.firestore.pipeline.Expression... otherStrings) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that concatenates string expressions together. - * - * ```kotlin - * // Combine the 'firstName', " ", and 'lastName' fields into a single string - * stringConcat(field("firstName"), " ", field("lastName")) - * ``` - * - * @param firstString The expression representing the initial string value. - * @param otherStrings Optional additional string expressions or string constants to - * concatenate. - * @return A new [Expression] representing the concatenated string. - */ - -public static final com.google.firebase.firestore.pipeline.Expression stringConcat(com.google.firebase.firestore.pipeline.Expression firstString, java.lang.Object... otherStrings) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that concatenates string expressions together. - * - * ```kotlin - * // Combine the 'firstName', " ", and 'lastName' fields into a single string - * stringConcat("firstName", constant(" "), field("lastName")) - * ``` - * - * @param fieldName The field name containing the initial string value. - * @param otherStrings Optional additional string expressions to concatenate. - * @return A new [Expression] representing the concatenated string. - */ - -public static final com.google.firebase.firestore.pipeline.Expression stringConcat(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression... otherStrings) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that concatenates string expressions together. - * - * ```kotlin - * // Combine the 'firstName', " ", and 'lastName' fields into a single string - * stringConcat("firstName", " ", "lastName") - * ``` - * - * @param fieldName The field name containing the initial string value. - * @param otherStrings Optional additional string expressions or string constants to - * concatenate. - * @return A new [Expression] representing the concatenated string. - */ - -public static final com.google.firebase.firestore.pipeline.Expression stringConcat(java.lang.String fieldName, java.lang.Object... otherStrings) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that creates a Firestore map value from an input object. - * - * ```kotlin - * // Create a map with a constant key and a field value - * map(mapOf("name" to field("productName"), "quantity" to 1)) - * ``` - * - * @param elements The input map to evaluate in the expression. - * @return A new [Expression] representing the map function. - */ - -public static final com.google.firebase.firestore.pipeline.Expression map(java.util.Map elements) { throw new RuntimeException("Stub!"); } - -/** - * Accesses a field/property of a document or Map using the provided [key]. - * - * @param expression The expression evaluating to a map or document. - * @param key The key of the field to access. - * @return An [Expression] representing the value of the field. - */ - -public static final com.google.firebase.firestore.pipeline.Expression getField(com.google.firebase.firestore.pipeline.Expression expression, java.lang.String key) { throw new RuntimeException("Stub!"); } - -/** - * Accesses a field/property of a document or Map using the provided [key]. - * - * @param fieldName The field name of the map or document field. - * @param key The key of the field to access. - * @return An [Expression] representing the value of the field. - */ - -public static final com.google.firebase.firestore.pipeline.Expression getField(java.lang.String fieldName, java.lang.String key) { throw new RuntimeException("Stub!"); } - -/** - * Accesses a field/property of a document or Map using the provided [keyExpression]. - * - * @param expression The expression evaluating to a Map or Document. - * @param keyExpression The expression evaluating to the key. - * @return A new [Expression] representing the value of the field. - */ - -public static final com.google.firebase.firestore.pipeline.Expression getField(com.google.firebase.firestore.pipeline.Expression expression, com.google.firebase.firestore.pipeline.Expression keyExpression) { throw new RuntimeException("Stub!"); } - -/** - * Accesses a field/property of a document or Map using the provided [keyExpression]. - * - * @param fieldName The field name of the map or document field. - * @param keyExpression The expression evaluating to the key. - * @return A new [Expression] representing the value of the field. - */ - -public static final com.google.firebase.firestore.pipeline.Expression getField(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression keyExpression) { throw new RuntimeException("Stub!"); } - -/** - * Accesses a value from a map (object) field using the provided [key]. - * - * ```kotlin - * // Get the 'city' value from the 'address' map field - * mapGet(field("address"), "city") - * ``` - * - * @param mapExpression The expression representing the map. - * @param key The key to access in the map. - * @return A new [Expression] representing the value associated with the given key in the map. - */ - -public static final com.google.firebase.firestore.pipeline.Expression mapGet(com.google.firebase.firestore.pipeline.Expression mapExpression, java.lang.String key) { throw new RuntimeException("Stub!"); } - -/** - * Accesses a value from a map (object) field using the provided [key]. - * - * ```kotlin - * // Get the 'city' value from the 'address' map field - * mapGet("address", "city") - * ``` - * - * @param fieldName The field name of the map field. - * @param key The key to access in the map. - * @return A new [Expression] representing the value associated with the given key in the map. - */ - -public static final com.google.firebase.firestore.pipeline.Expression mapGet(java.lang.String fieldName, java.lang.String key) { throw new RuntimeException("Stub!"); } - -/** - * Accesses a value from a map (object) field using the provided [keyExpression]. - * - * ```kotlin - * // Get the value from the 'address' map field, using the key from the 'keyField' field - * mapGet(field("address"), field("keyField")) - * ``` - * - * @param mapExpression The expression representing the map. - * @param keyExpression The key to access in the map. - * @return A new [Expression] representing the value associated with the given key in the map. - */ - -public static final com.google.firebase.firestore.pipeline.Expression mapGet(com.google.firebase.firestore.pipeline.Expression mapExpression, com.google.firebase.firestore.pipeline.Expression keyExpression) { throw new RuntimeException("Stub!"); } - -/** - * Accesses a value from a map (object) field using the provided [keyExpression]. - * - * ```kotlin - * // Get the value from the 'address' map field, using the key from the 'keyField' field - * mapGet("address", field("keyField")) - * ``` - * - * @param fieldName The field name of the map field. - * @param keyExpression The key to access in the map. - * @return A new [Expression] representing the value associated with the given key in the map. - */ - -public static final com.google.firebase.firestore.pipeline.Expression mapGet(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression keyExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that merges multiple maps into a single map. If multiple maps have the - * same key, the later value is used. - * - * ```kotlin - * // Merges the map in the settings field with, a map literal, and a map in - * // that is conditionally returned by another expression - * mapMerge( - * field("settings"), - * map(mapOf("enabled" to true)), - * conditional( - * field("isAdmin").equal(true), - * map(mapOf("admin" to true)), - * map(emptyMap()) - * ) - * ) - * ``` - * - * @param firstMap First map expression that will be merged. - * @param secondMap Second map expression that will be merged. - * @param otherMaps Additional maps to merge. - * @return A new [Expression] representing the mapMerge operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression mapMerge(com.google.firebase.firestore.pipeline.Expression firstMap, com.google.firebase.firestore.pipeline.Expression secondMap, com.google.firebase.firestore.pipeline.Expression... otherMaps) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that merges multiple maps into a single map. If multiple maps have the - * same key, the later value is used. - * - * ```kotlin - * // Merges the map in the settings field with, a map literal, and a map in - * // that is conditionally returned by another expression - * mapMerge( - * "settings", - * map(mapOf("enabled" to true)), - * conditional( - * field("isAdmin").equal(true), - * map(mapOf("admin" to true)), - * map(emptyMap()) - * ) - * ) - * ``` - * - * @param firstMapFieldName First map field name that will be merged. - * @param secondMap Second map expression that will be merged. - * @param otherMaps Additional maps to merge. - * @return A new [Expression] representing the mapMerge operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression mapMerge(java.lang.String firstMapFieldName, com.google.firebase.firestore.pipeline.Expression secondMap, com.google.firebase.firestore.pipeline.Expression... otherMaps) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes a key from the map produced by evaluating an expression. - * - * ```kotlin - * // Removes the key 'baz' from the input map. - * mapRemove(map(mapOf("foo" to "bar", "baz" to true)), constant("baz")) - * ``` - * - * @param mapExpr An expression that evaluates to a map. - * @param key The name of the key to remove from the input map. - * @return A new [Expression] that evaluates to a modified map. - */ - -public static final com.google.firebase.firestore.pipeline.Expression mapRemove(com.google.firebase.firestore.pipeline.Expression mapExpr, com.google.firebase.firestore.pipeline.Expression key) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes a key from the map produced by evaluating an expression. - * - * ```kotlin - * // Removes the key 'city' field from the map in the address field of the input document. - * mapRemove("address", constant("city")) - * ``` - * - * @param mapField The name of a field containing a map value. - * @param key The name of the key to remove from the input map. - * @return A new [Expression] that evaluates to a modified map. - */ - -public static final com.google.firebase.firestore.pipeline.Expression mapRemove(java.lang.String mapField, com.google.firebase.firestore.pipeline.Expression key) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes a key from the map produced by evaluating an expression. - * - * ```kotlin - * // Removes the key 'baz' from the input map. - * mapRemove(map(mapOf("foo" to "bar", "baz" to true)), "baz") - * ``` - * - * @param mapExpr An expression that evaluates to a map. - * @param key The name of the key to remove from the input map. - * @return A new [Expression] that evaluates to a modified map. - */ - -public static final com.google.firebase.firestore.pipeline.Expression mapRemove(com.google.firebase.firestore.pipeline.Expression mapExpr, java.lang.String key) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes a key from the map produced by evaluating an expression. - * - * ```kotlin - * // Removes the key 'city' field from the map in the address field of the input document. - * mapRemove("address", "city") - * ``` - * - * @param mapField The name of a field containing a map value. - * @param key The name of the key to remove from the input map. - * @return A new [Expression] that evaluates to a modified map. - */ - -public static final com.google.firebase.firestore.pipeline.Expression mapRemove(java.lang.String mapField, java.lang.String key) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a new map with the specified entries added or updated. - * - * Note: This only performs shallow updates to the map. Setting a value to `null` will retain - * the key with a `null` value. To remove a key entirely, use `mapRemove`. - * - * ```kotlin - * // Set the 'city' to "San Francisco" in the 'address' map - * mapSet(field("address"), constant("city"), constant("San Francisco")); - * ``` - * - * @param mapExpr The expression representing the map. - * @param key The key to set. Must be an expression representing a string. - * @param value The value to set. - * @param moreKeyValues Additional key-value pairs to set. - * @return A new [Expression] representing the map with the entries set. - */ - -public static final com.google.firebase.firestore.pipeline.Expression mapSet(com.google.firebase.firestore.pipeline.Expression mapExpr, com.google.firebase.firestore.pipeline.Expression key, com.google.firebase.firestore.pipeline.Expression value, com.google.firebase.firestore.pipeline.Expression... moreKeyValues) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a new map with the specified entries added or updated. - * - * Note: This only performs shallow updates to the map. Setting a value to `null` will retain - * the key with a `null` value. To remove a key entirely, use `mapRemove`. - * - * ```kotlin - * // Set the 'city' to "San Francisco" in the 'address' map - * mapSet(field("address"), "city", "San Francisco"); - * ``` - * - * @param mapExpr The map field to set entries in. - * @param key The key to set. - * @param value The value to set. - * @param moreKeyValues Additional key-value pairs to set. - * @return A new [Expression] representing the map with the entries set. - */ - -public static final com.google.firebase.firestore.pipeline.Expression mapSet(com.google.firebase.firestore.pipeline.Expression mapExpr, java.lang.String key, java.lang.Object value, java.lang.Object... moreKeyValues) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a new map with the specified entries added or updated. - * - * Note: This only performs shallow updates to the map. Setting a value to `null` will retain - * the key with a `null` value. To remove a key entirely, use `mapRemove`. - * - * ```kotlin - * // Set the 'city' to "San Francisco" in the 'address' map - * mapSet("address", constant("city"), constant("San Francisco")) - * ``` - * - * @param mapField The map field to set entries in. - * @param key The key to set. Must be an expression representing a string. - * @param value The value to set. - * @param moreKeyValues Additional key-value pairs to set. - * @return A new [Expression] representing the map with the entries set. - */ - -public static final com.google.firebase.firestore.pipeline.Expression mapSet(java.lang.String mapField, com.google.firebase.firestore.pipeline.Expression key, com.google.firebase.firestore.pipeline.Expression value, com.google.firebase.firestore.pipeline.Expression... moreKeyValues) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a new map with the specified entries added or updated. - * - * Note: This only performs shallow updates to the map. Setting a value to `null` will retain - * the key with a `null` value. To remove a key entirely, use `mapRemove`. - * - * ```kotlin - * // Set the 'city' to "San Francisco" in the 'address' map - * mapSet("address", "city", "San Francisco") - * ``` - * - * @param mapField The map field to set entries in. - * @param key The key to set. Must be an expression representing a string. - * @param value The value to set. - * @param moreKeyValues Additional key-value pairs to set. - * @return A new [Expression] representing the map with the entries set. - */ - -public static final com.google.firebase.firestore.pipeline.Expression mapSet(java.lang.String mapField, java.lang.String key, java.lang.Object value, java.lang.Object... moreKeyValues) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the keys of a map. - * - * Note: While the backend generally preserves insertion order, relying on the order of the - * output array is not guaranteed and should be avoided. - * - * ```kotlin - * // Get the keys of a map expression. - * mapKeys(map(mapOf("a" to 1, "b" to 2))) - * ``` - * - * @param mapExpr The expression representing the map to get the keys of. - * @return A new [Expression] representing the keys of the map. - */ - -public static final com.google.firebase.firestore.pipeline.Expression mapKeys(com.google.firebase.firestore.pipeline.Expression mapExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the keys of a map. - * - * Note: While the backend generally preserves insertion order, relying on the order of the - * output array is not guaranteed and should be avoided. - * - * ```kotlin - * // Get the keys of the 'metadata' map field. - * mapKeys("metadata") - * ``` - * - * @param mapField The map field to get the keys of. - * @return A new [Expression] representing the keys of the map. - */ - -public static final com.google.firebase.firestore.pipeline.Expression mapKeys(java.lang.String mapField) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the values of a map. - * - * Note: While the backend generally preserves insertion order, relying on the order of the - * output array is not guaranteed and should be avoided. - * - * ```kotlin - * // Get the values of a map expression. - * mapValues(map(mapOf("a" to 1, "b" to 2))) - * ``` - * - * @param mapExpr The expression representing the map to get the values of. - * @return A new [Expression] representing the values of the map. - */ - -public static final com.google.firebase.firestore.pipeline.Expression mapValues(com.google.firebase.firestore.pipeline.Expression mapExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the values of a map. - * - * Note: While the backend generally preserves insertion order, relying on the order of the - * output array is not guaranteed and should be avoided. - * - * ```kotlin - * // Get the values of the 'metadata' map field. - * mapValues("metadata") - * ``` - * - * @param mapField The map field to get the values of. - * @return A new [Expression] representing the values of the map. - */ - -public static final com.google.firebase.firestore.pipeline.Expression mapValues(java.lang.String mapField) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the entries of a map as an array of maps, where each map - * contains a "k" property for the key and a "v" property for the value. - * - * Note: While the backend generally preserves insertion order, relying on the order of the - * output array is not guaranteed and should be avoided. - * - * ```kotlin - * // Get the entries of a map expression. - * mapEntries(map(mapOf("a" to 1, "b" to 2))) - * ``` - * - * @param mapExpr The expression representing the map to get the entries of. - * @return A new [Expression] representing the entries of the map. - */ - -public static final com.google.firebase.firestore.pipeline.Expression mapEntries(com.google.firebase.firestore.pipeline.Expression mapExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the entries of a map as an array of maps. - * - * Note: While the backend generally preserves insertion order, relying on the order of the - * output array is not guaranteed and should be avoided. - * - * ```kotlin - * // Get the entries of the 'metadata' map field. - * mapEntries("metadata") - * ``` - * - * @param mapField The map field to get the entries of. - * @return A new [Expression] representing the entries of the map. - */ - -public static final com.google.firebase.firestore.pipeline.Expression mapEntries(java.lang.String mapField) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the Cosine distance between two vector expressions. - * - * ```kotlin - * // Calculate the cosine distance between the 'userVector' field and the 'itemVector' field - * cosineDistance(field("userVector"), field("itemVector")) - * ``` - * - * @param vector1 The first vector (represented as an Expression) to compare against. - * @param vector2 The other vector (represented as an Expression) to compare against. - * @return A new [Expression] representing the cosine distance between the two vectors. - */ - -public static final com.google.firebase.firestore.pipeline.Expression cosineDistance(com.google.firebase.firestore.pipeline.Expression vector1, com.google.firebase.firestore.pipeline.Expression vector2) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the Cosine distance between vector expression and a vector literal. - * - * ```kotlin - * // Calculate the Cosine distance between the 'location' field and a target location - * cosineDistance(field("location"), doubleArrayOf(37.7749, -122.4194)) - * ``` - * - * @param vector1 The first vector (represented as an Expression) to compare against. - * @param vector2 The other vector (as an array of doubles) to compare against. - * @return A new [Expression] representing the cosine distance between the two vectors. - */ - -public static final com.google.firebase.firestore.pipeline.Expression cosineDistance(com.google.firebase.firestore.pipeline.Expression vector1, double[] vector2) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the Cosine distance between vector expression and a vector literal. - * - * ```kotlin - * // Calculate the Cosine distance between the 'location' field and a target location - * cosineDistance(field("location"), VectorValue.from(listOf(37.7749, -122.4194))) - * ``` - * - * @param vector1 The first vector (represented as an [Expression]) to compare against. - * @param vector2 The other vector (represented as an [VectorValue]) to compare against. - * @return A new [Expression] representing the cosine distance between the two vectors. - */ - -public static final com.google.firebase.firestore.pipeline.Expression cosineDistance(com.google.firebase.firestore.pipeline.Expression vector1, com.google.firebase.firestore.VectorValue vector2) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the Cosine distance between a vector field and a vector expression. - * - * ```kotlin - * // Calculate the cosine distance between the 'userVector' field and the 'itemVector' field - * cosineDistance("userVector", field("itemVector")) - * ``` - * - * @param vectorFieldName The name of the field containing the first vector. - * @param vector The other vector (represented as an Expression) to compare against. - * @return A new [Expression] representing the cosine distance between the two vectors. - */ - -public static final com.google.firebase.firestore.pipeline.Expression cosineDistance(java.lang.String vectorFieldName, com.google.firebase.firestore.pipeline.Expression vector) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the Cosine distance between a vector field and a vector literal. - * - * ```kotlin - * // Calculate the Cosine distance between the 'location' field and a target location - * cosineDistance("location", doubleArrayOf(37.7749, -122.4194)) - * ``` - * - * @param vectorFieldName The name of the field containing the first vector. - * @param vector The other vector (as an array of doubles) to compare against. - * @return A new [Expression] representing the cosine distance between the two vectors. - */ - -public static final com.google.firebase.firestore.pipeline.Expression cosineDistance(java.lang.String vectorFieldName, double[] vector) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the Cosine distance between a vector field and a vector literal. - * - * ```kotlin - * // Calculate the Cosine distance between the 'location' field and a target location - * cosineDistance("location", VectorValue.from(listOf(37.7749, -122.4194))) - * ``` - * - * @param vectorFieldName The name of the field containing the first vector. - * @param vector The other vector (represented as an [VectorValue]) to compare against. - * @return A new [Expression] representing the cosine distance between the two vectors. - */ - -public static final com.google.firebase.firestore.pipeline.Expression cosineDistance(java.lang.String vectorFieldName, com.google.firebase.firestore.VectorValue vector) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the dot product distance between two vector expressions. - * - * ```kotlin - * // Calculate the dot product between the 'userVector' field and the 'itemVector' field - * dotProduct(field("userVector"), field("itemVector")) - * ``` - * - * @param vector1 The first vector (represented as an Expression) to compare against. - * @param vector2 The other vector (represented as an Expression) to compare against. - * @return A new [Expression] representing the dot product distance between the two vectors. - */ - -public static final com.google.firebase.firestore.pipeline.Expression dotProduct(com.google.firebase.firestore.pipeline.Expression vector1, com.google.firebase.firestore.pipeline.Expression vector2) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the dot product distance between vector expression and a vector literal. - * - * ```kotlin - * // Calculate the dot product between the 'vector' field and a constant vector - * dotProduct(field("vector"), doubleArrayOf(1.0, 2.0, 3.0)) - * ``` - * - * @param vector1 The first vector (represented as an Expression) to compare against. - * @param vector2 The other vector (as an array of doubles) to compare against. - * @return A new [Expression] representing the dot product distance between the two vectors. - */ - -public static final com.google.firebase.firestore.pipeline.Expression dotProduct(com.google.firebase.firestore.pipeline.Expression vector1, double[] vector2) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the dot product distance between vector expression and a vector literal. - * - * ```kotlin - * // Calculate the dot product between the 'vector' field and a constant vector - * dotProduct(field("vector"), VectorValue.from(listOf(1.0, 2.0, 3.0))) - * ``` - * - * @param vector1 The first vector (represented as an [Expression]) to compare against. - * @param vector2 The other vector (represented as an [VectorValue]) to compare against. - * @return A new [Expression] representing the dot product distance between the two vectors. - */ - -public static final com.google.firebase.firestore.pipeline.Expression dotProduct(com.google.firebase.firestore.pipeline.Expression vector1, com.google.firebase.firestore.VectorValue vector2) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the dot product distance between a vector field and a vector expression. - * - * ```kotlin - * // Calculate the dot product between the 'userVector' field and the 'itemVector' field - * dotProduct("userVector", field("itemVector")) - * ``` - * - * @param vectorFieldName The name of the field containing the first vector. - * @param vector The other vector (represented as an Expression) to compare against. - * @return A new [Expression] representing the dot product distance between the two vectors. - */ - -public static final com.google.firebase.firestore.pipeline.Expression dotProduct(java.lang.String vectorFieldName, com.google.firebase.firestore.pipeline.Expression vector) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the dot product distance between vector field and a vector literal. - * - * ```kotlin - * // Calculate the dot product between the 'vector' field and a constant vector - * dotProduct("vector", doubleArrayOf(1.0, 2.0, 3.0)) - * ``` - * - * @param vectorFieldName The name of the field containing the first vector. - * @param vector The other vector (as an array of doubles) to compare against. - * @return A new [Expression] representing the dot product distance between the two vectors. - */ - -public static final com.google.firebase.firestore.pipeline.Expression dotProduct(java.lang.String vectorFieldName, double[] vector) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the dot product distance between a vector field and a vector literal. - * - * ```kotlin - * // Calculate the dot product between the 'vector' field and a constant vector - * dotProduct("vector", VectorValue.from(listOf(1.0, 2.0, 3.0))) - * ``` - * - * @param vectorFieldName The name of the field containing the first vector. - * @param vector The other vector (represented as an [VectorValue]) to compare against. - * @return A new [Expression] representing the dot product distance between the two vectors. - */ - -public static final com.google.firebase.firestore.pipeline.Expression dotProduct(java.lang.String vectorFieldName, com.google.firebase.firestore.VectorValue vector) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the Euclidean distance between two vector expressions. - * - * ```kotlin - * // Calculate the Euclidean distance between the 'userVector' field and the 'itemVector' field - * euclideanDistance(field("userVector"), field("itemVector")) - * ``` - * - * @param vector1 The first vector (represented as an Expression) to compare against. - * @param vector2 The other vector (represented as an Expression) to compare against. - * @return A new [Expression] representing the Euclidean distance between the two vectors. - */ - -public static final com.google.firebase.firestore.pipeline.Expression euclideanDistance(com.google.firebase.firestore.pipeline.Expression vector1, com.google.firebase.firestore.pipeline.Expression vector2) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the Euclidean distance between vector expression and a vector literal. - * - * ```kotlin - * // Calculate the Euclidean distance between the 'vector' field and a constant vector - * euclideanDistance(field("vector"), doubleArrayOf(1.0, 2.0, 3.0)) - * ``` - * - * @param vector1 The first vector (represented as an Expression) to compare against. - * @param vector2 The other vector (as an array of doubles) to compare against. - * @return A new [Expression] representing the Euclidean distance between the two vectors. - */ - -public static final com.google.firebase.firestore.pipeline.Expression euclideanDistance(com.google.firebase.firestore.pipeline.Expression vector1, double[] vector2) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the Euclidean distance between vector expression and a vector literal. - * - * ```kotlin - * // Calculate the Euclidean distance between the 'vector' field and a constant vector - * euclideanDistance(field("vector"), VectorValue.from(listOf(1.0, 2.0, 3.0))) - * ``` - * - * @param vector1 The first vector (represented as an [Expression]) to compare against. - * @param vector2 The other vector (represented as an [VectorValue]) to compare against. - * @return A new [Expression] representing the Euclidean distance between the two vectors. - */ - -public static final com.google.firebase.firestore.pipeline.Expression euclideanDistance(com.google.firebase.firestore.pipeline.Expression vector1, com.google.firebase.firestore.VectorValue vector2) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the Euclidean distance between a vector field and a vector expression. - * - * ```kotlin - * // Calculate the Euclidean distance between the 'userVector' field and the 'itemVector' field - * euclideanDistance("userVector", field("itemVector")) - * ``` - * - * @param vectorFieldName The name of the field containing the first vector. - * @param vector The other vector (represented as an Expression) to compare against. - * @return A new [Expression] representing the Euclidean distance between the two vectors. - */ - -public static final com.google.firebase.firestore.pipeline.Expression euclideanDistance(java.lang.String vectorFieldName, com.google.firebase.firestore.pipeline.Expression vector) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the Euclidean distance between a vector field and a vector literal. - * - * ```kotlin - * // Calculate the Euclidean distance between the 'vector' field and a constant vector - * euclideanDistance("vector", doubleArrayOf(1.0, 2.0, 3.0)) - * ``` - * - * @param vectorFieldName The name of the field containing the first vector. - * @param vector The other vector (as an array of doubles) to compare against. - * @return A new [Expression] representing the Euclidean distance between the two vectors. - */ - -public static final com.google.firebase.firestore.pipeline.Expression euclideanDistance(java.lang.String vectorFieldName, double[] vector) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the Euclidean distance between a vector field and a vector literal. - * - * ```kotlin - * // Calculate the Euclidean distance between the 'vector' field and a constant vector - * euclideanDistance("vector", VectorValue.from(listOf(1.0, 2.0, 3.0))) - * ``` - * - * @param vectorFieldName The name of the field containing the first vector. - * @param vector The other vector (represented as an [VectorValue]) to compare against. - * @return A new [Expression] representing the Euclidean distance between the two vectors. - */ - -public static final com.google.firebase.firestore.pipeline.Expression euclideanDistance(java.lang.String vectorFieldName, com.google.firebase.firestore.VectorValue vector) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the length (dimension) of a Firestore Vector. - * - * ```kotlin - * // Get the vector length (dimension) of the field 'embedding'. - * vectorLength(field("embedding")) - * ``` - * - * @param vectorExpression The expression representing the Firestore Vector. - * @return A new [Expression] representing the length (dimension) of the vector. - */ - -public static final com.google.firebase.firestore.pipeline.Expression vectorLength(com.google.firebase.firestore.pipeline.Expression vectorExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the length (dimension) of a Firestore Vector. - * - * ```kotlin - * // Get the vector length (dimension) of the field 'embedding'. - * vectorLength("embedding") - * ``` - * - * @param fieldName The name of the field containing the Firestore Vector. - * @return A new [Expression] representing the length (dimension) of the vector. - */ - -public static final com.google.firebase.firestore.pipeline.Expression vectorLength(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that evaluates to the current server timestamp. - * - * ```kotlin - * // Get the current server timestamp - * currentTimestamp() - * ``` - * - * @return A new [Expression] representing the current server timestamp. - */ - -public static final com.google.firebase.firestore.pipeline.Expression currentTimestamp() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that interprets an expression as the number of microseconds since the - * Unix epoch (1970-01-01 00:00:00 UTC) and returns a timestamp. - * - * ```kotlin - * // Interpret the 'microseconds' field as microseconds since epoch. - * unixMicrosToTimestamp(field("microseconds")) - * ``` - * - * @param expr The expression representing the number of microseconds since epoch. - * @return A new [Expression] representing the timestamp. - */ - -public static final com.google.firebase.firestore.pipeline.Expression unixMicrosToTimestamp(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that interprets a field's value as the number of microseconds since the - * Unix epoch (1970-01-01 00:00:00 UTC) and returns a timestamp. - * - * ```kotlin - * // Interpret the 'microseconds' field as microseconds since epoch. - * unixMicrosToTimestamp("microseconds") - * ``` - * - * @param fieldName The name of the field containing the number of microseconds since epoch. - * @return A new [Expression] representing the timestamp. - */ - -public static final com.google.firebase.firestore.pipeline.Expression unixMicrosToTimestamp(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that converts a timestamp expression to the number of microseconds - * since the Unix epoch (1970-01-01 00:00:00 UTC). - * - * ```kotlin - * // Convert the 'timestamp' field to microseconds since epoch. - * timestampToUnixMicros(field("timestamp")) - * ``` - * - * @param expr The expression representing the timestamp. - * @return A new [Expression] representing the number of microseconds since epoch. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampToUnixMicros(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that converts a timestamp field to the number of microseconds since the - * Unix epoch (1970-01-01 00:00:00 UTC). - * - * ```kotlin - * // Convert the 'timestamp' field to microseconds since epoch. - * timestampToUnixMicros("timestamp") - * ``` - * - * @param fieldName The name of the field that contains the timestamp. - * @return A new [Expression] representing the number of microseconds since epoch. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampToUnixMicros(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that interprets an expression as the number of milliseconds since the - * Unix epoch (1970-01-01 00:00:00 UTC) and returns a timestamp. - * - * ```kotlin - * // Interpret the 'milliseconds' field as milliseconds since epoch. - * unixMillisToTimestamp(field("milliseconds")) - * ``` - * - * @param expr The expression representing the number of milliseconds since epoch. - * @return A new [Expression] representing the timestamp. - */ - -public static final com.google.firebase.firestore.pipeline.Expression unixMillisToTimestamp(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that interprets a field's value as the number of milliseconds since the - * Unix epoch (1970-01-01 00:00:00 UTC) and returns a timestamp. - * - * ```kotlin - * // Interpret the 'milliseconds' field as milliseconds since epoch. - * unixMillisToTimestamp("milliseconds") - * ``` - * - * @param fieldName The name of the field containing the number of milliseconds since epoch. - * @return A new [Expression] representing the timestamp. - */ - -public static final com.google.firebase.firestore.pipeline.Expression unixMillisToTimestamp(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that converts a timestamp expression to the number of milliseconds - * since the Unix epoch (1970-01-01 00:00:00 UTC). - * - * ```kotlin - * // Convert the 'timestamp' field to milliseconds since epoch. - * timestampToUnixMillis(field("timestamp")) - * ``` - * - * @param expr The expression representing the timestamp. - * @return A new [Expression] representing the number of milliseconds since epoch. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampToUnixMillis(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that converts a timestamp field to the number of milliseconds since the - * Unix epoch (1970-01-01 00:00:00 UTC). - * - * ```kotlin - * // Convert the 'timestamp' field to milliseconds since epoch. - * timestampToUnixMillis("timestamp") - * ``` - * - * @param fieldName The name of the field that contains the timestamp. - * @return A new [Expression] representing the number of milliseconds since epoch. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampToUnixMillis(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that interprets an expression as the number of seconds since the Unix - * epoch (1970-01-01 00:00:00 UTC) and returns a timestamp. - * - * ```kotlin - * // Interpret the 'seconds' field as seconds since epoch. - * unixSecondsToTimestamp(field("seconds")) - * ``` - * - * @param expr The expression representing the number of seconds since epoch. - * @return A new [Expression] representing the timestamp. - */ - -public static final com.google.firebase.firestore.pipeline.Expression unixSecondsToTimestamp(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that interprets a field's value as the number of seconds since the Unix - * epoch (1970-01-01 00:00:00 UTC) and returns a timestamp. - * - * ```kotlin - * // Interpret the 'seconds' field as seconds since epoch. - * unixSecondsToTimestamp("seconds") - * ``` - * - * @param fieldName The name of the field containing the number of seconds since epoch. - * @return A new [Expression] representing the timestamp. - */ - -public static final com.google.firebase.firestore.pipeline.Expression unixSecondsToTimestamp(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that converts a timestamp expression to the number of seconds since the - * Unix epoch (1970-01-01 00:00:00 UTC). - * - * ```kotlin - * // Convert the 'timestamp' field to seconds since epoch. - * timestampToUnixSeconds(field("timestamp")) - * ``` - * - * @param expr The expression representing the timestamp. - * @return A new [Expression] representing the number of seconds since epoch. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampToUnixSeconds(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that converts a timestamp field to the number of seconds since the Unix - * epoch (1970-01-01 00:00:00 UTC). - * - * ```kotlin - * // Convert the 'timestamp' field to seconds since epoch. - * timestampToUnixSeconds("timestamp") - * ``` - * - * @param fieldName The name of the field that contains the timestamp. - * @return A new [Expression] representing the number of seconds since epoch. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampToUnixSeconds(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that adds a specified amount of time to a timestamp. - * - * ```kotlin - * // Add some duration determined by field 'unit' and 'amount' to the 'timestamp' field. - * timestampAdd(field("timestamp"), field("unit"), field("amount")) - * ``` - * - * @param timestamp The expression representing the timestamp. - * @param unit The expression representing the unit of time to add. Valid units include - * "microsecond", "millisecond", "second", "minute", "hour" and "day". - * @param amount The expression representing the amount of time to add. - * @return A new [Expression] representing the resulting timestamp. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampAdd(com.google.firebase.firestore.pipeline.Expression timestamp, com.google.firebase.firestore.pipeline.Expression unit, com.google.firebase.firestore.pipeline.Expression amount) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that adds a specified amount of time to a timestamp. - * - * ```kotlin - * // Add 1 day to the 'timestamp' field. - * timestampAdd(field("timestamp"), "day", 1) - * ``` - * - * @param timestamp The expression representing the timestamp. - * @param unit The unit of time to add. Valid units include "microsecond", "millisecond", - * "second", "minute", "hour" and "day". - * @param amount The amount of time to add. - * @return A new [Expression] representing the resulting timestamp. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampAdd(com.google.firebase.firestore.pipeline.Expression timestamp, java.lang.String unit, long amount) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that adds a specified amount of time to a timestamp. - * - * ```kotlin - * // Add some duration determined by field 'unit' and 'amount' to the 'timestamp' field. - * timestampAdd("timestamp", field("unit"), field("amount")) - * ``` - * - * @param fieldName The name of the field that contains the timestamp. - * @param unit The expression representing the unit of time to add. Valid units include - * "microsecond", "millisecond", "second", "minute", "hour" and "day". - * @param amount The expression representing the amount of time to add. - * @return A new [Expression] representing the resulting timestamp. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampAdd(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression unit, com.google.firebase.firestore.pipeline.Expression amount) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that adds a specified amount of time to a timestamp. - * - * ```kotlin - * // Add 1 day to the 'timestamp' field. - * timestampAdd("timestamp", "day", 1) - * ``` - * - * @param fieldName The name of the field that contains the timestamp. - * @param unit The unit of time to add. Valid units include "microsecond", "millisecond", - * "second", "minute", "hour" and "day". - * @param amount The amount of time to add. - * @return A new [Expression] representing the resulting timestamp. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampAdd(java.lang.String fieldName, java.lang.String unit, long amount) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that subtracts a specified amount of time to a timestamp. - * - * ```kotlin - * // Subtract some duration determined by field 'unit' and 'amount' from the 'timestamp' field. - * timestampSubtract(field("timestamp"), field("unit"), field("amount")) - * ``` - * - * @param timestamp The expression representing the timestamp. - * @param unit The expression representing the unit of time to subtract. Valid units include - * "microsecond", "millisecond", "second", "minute", "hour" and "day". - * @param amount The expression representing the amount of time to subtract. - * @return A new [Expression] representing the resulting timestamp. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampSubtract(com.google.firebase.firestore.pipeline.Expression timestamp, com.google.firebase.firestore.pipeline.Expression unit, com.google.firebase.firestore.pipeline.Expression amount) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that subtracts a specified amount of time to a timestamp. - * - * ```kotlin - * // Subtract 1 day from the 'timestamp' field. - * timestampSubtract(field("timestamp"), "day", 1) - * ``` - * - * @param timestamp The expression representing the timestamp. - * @param unit The unit of time to subtract. Valid units include "microsecond", "millisecond", - * "second", "minute", "hour" and "day". - * @param amount The amount of time to subtract. - * @return A new [Expression] representing the resulting timestamp. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampSubtract(com.google.firebase.firestore.pipeline.Expression timestamp, java.lang.String unit, long amount) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that subtracts a specified amount of time to a timestamp. - * - * ```kotlin - * // Subtract some duration determined by field 'unit' and 'amount' from the 'timestamp' field. - * timestampSubtract("timestamp", field("unit"), field("amount")) - * ``` - * - * @param fieldName The name of the field that contains the timestamp. - * @param unit The unit of time to subtract. Valid units include "microsecond", "millisecond", - * "second", "minute", "hour" and "day". - * @param amount The amount of time to subtract. - * @return A new [Expression] representing the resulting timestamp. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampSubtract(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression unit, com.google.firebase.firestore.pipeline.Expression amount) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that subtracts a specified amount of time to a timestamp. - * - * ```kotlin - * // Subtract 1 day from the 'timestamp' field. - * timestampSubtract("timestamp", "day", 1) - * ``` - * - * @param fieldName The name of the field that contains the timestamp. - * @param unit The unit of time to subtract. Valid units include "microsecond", "millisecond", - * "second", "minute", "hour" and "day". - * @param amount The amount of time to subtract. - * @return A new [Expression] representing the resulting timestamp. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampSubtract(java.lang.String fieldName, java.lang.String unit, long amount) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates a timestamp to a specified granularity. - * - * ```kotlin - * // Truncate the 'createdAt' timestamp to the beginning of the day. - * timestampTruncate(field("createdAt"), "day") - * ``` - * - * @param timestamp The timestamp expression. - * @param granularity The granularity to truncate to. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @return A new [Expression] representing the truncated timestamp. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampTruncate(com.google.firebase.firestore.pipeline.Expression timestamp, java.lang.String granularity) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates a timestamp to a specified granularity. - * - * ```kotlin - * // Truncate the 'createdAt' timestamp to the beginning of the day. - * timestampTruncate(field("createdAt"), field("granularity")) - * ``` - * - * @param timestamp The timestamp expression. - * @param granularity The granularity expression to truncate to. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @return A new [Expression] representing the truncated timestamp. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampTruncate(com.google.firebase.firestore.pipeline.Expression timestamp, com.google.firebase.firestore.pipeline.Expression granularity) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates a timestamp to a specified granularity. - * - * ```kotlin - * // Truncate the 'createdAt' timestamp to the beginning of the day. - * timestampTruncate("createdAt", "day") - * ``` - * - * @param fieldName The name of the field containing the timestamp. - * @param granularity The granularity to truncate to. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @return A new [Expression] representing the truncated timestamp. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampTruncate(java.lang.String fieldName, java.lang.String granularity) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates a timestamp to a specified granularity. - * - * ```kotlin - * // Truncate the 'createdAt' timestamp to the beginning of the day. - * timestampTruncate("createdAt", field("granularity")) - * ``` - * - * @param fieldName The name of the field containing the timestamp. - * @param granularity The granularity expression to truncate to. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @return A new [Expression] representing the truncated timestamp. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampTruncate(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression granularity) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates a timestamp to a specified granularity in a given - * timezone. - * - * ```kotlin - * // Truncate the 'createdAt' timestamp to the beginning of the day in "America/Los_Angeles" - * // timezone. - * timestampTruncateWithTimezone(field("createdAt"), "day", "America/Los_Angeles") - * ``` - * - * @param timestamp The timestamp expression. - * @param granularity The granularity to truncate to. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone to use for truncation. Valid values are from the TZ database - * (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". - * @return A new [Expression] representing the truncated timestamp. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(com.google.firebase.firestore.pipeline.Expression timestamp, java.lang.String granularity, java.lang.String timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates a timestamp to a specified granularity in a given - * timezone. - * - * ```kotlin - * // Truncate the 'createdAt' timestamp to the beginning of the day in "America/Los_Angeles" - * // timezone. - * timestampTruncateWithTimezone(field("createdAt"), field("granularity"), "America/Los_Angeles") - * ``` - * - * @param timestamp The timestamp expression. - * @param granularity The granularity expression to truncate to. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone to use for truncation. Valid values are from the TZ database - * (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". - * @return A new [Expression] representing the truncated timestamp. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(com.google.firebase.firestore.pipeline.Expression timestamp, com.google.firebase.firestore.pipeline.Expression granularity, java.lang.String timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates a timestamp to a specified granularity in a given - * timezone. - * - * ```kotlin - * // Truncate the 'createdAt' timestamp to the beginning of the day in "America/Los_Angeles" - * // timezone. - * timestampTruncateWithTimezone("createdAt", "day", "America/Los_Angeles") - * ``` - * - * @param fieldName The name of the field containing the timestamp. - * @param granularity The granularity to truncate to. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone to use for truncation. Valid values are from the TZ database - * (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". - * @return A new [Expression] representing the truncated timestamp. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(java.lang.String fieldName, java.lang.String granularity, java.lang.String timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates a timestamp to a specified granularity in a given - * timezone. - * - * ```kotlin - * // Truncate the 'createdAt' timestamp to the beginning of the day in "America/Los_Angeles" - * // timezone. - * timestampTruncateWithTimezone("createdAt", field("granularity"), "America/Los_Angeles") - * ``` - * - * @param fieldName The name of the field containing the timestamp. - * @param granularity The granularity expression to truncate to. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone to use for truncation. Valid values are from the TZ database - * (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". - * @return A new [Expression] representing the truncated timestamp. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression granularity, java.lang.String timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates a timestamp to a specified granularity in a given - * timezone. - * - * ```kotlin - * // Truncate the 'createdAt' timestamp to the beginning of the day in timezone specified by - * // the 'tz' field. - * timestampTruncateWithTimezone(field("createdAt"), "day", field("tz")) - * ``` - * - * @param timestamp The timestamp expression. - * @param granularity The granularity to truncate to. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone expression to use for truncation. Valid values are from the TZ - * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". - * @return A new [Expression] representing the truncated timestamp. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(com.google.firebase.firestore.pipeline.Expression timestamp, java.lang.String granularity, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates a timestamp to a specified granularity in a given - * timezone. - * - * ```kotlin - * // Truncate the 'createdAt' timestamp to the beginning of the day in timezone specified by - * // the 'tz' field. - * timestampTruncateWithTimezone(field("createdAt"), field("granularity"), field("tz")) - * ``` - * - * @param timestamp The timestamp expression. - * @param granularity The granularity expression to truncate to. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone expression to use for truncation. Valid values are from the TZ - * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". - * @return A new [Expression] representing the truncated timestamp. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(com.google.firebase.firestore.pipeline.Expression timestamp, com.google.firebase.firestore.pipeline.Expression granularity, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates a timestamp to a specified granularity in a given - * timezone. - * - * ```kotlin - * // Truncate the 'createdAt' timestamp to the beginning of the day in timezone specified by - * // the 'tz' field. - * timestampTruncateWithTimezone("createdAt", "day", field("tz")) - * ``` - * - * @param fieldName The name of the field containing the timestamp. - * @param granularity The granularity to truncate to. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone expression to use for truncation. Valid values are from the TZ - * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". - * @return A new [Expression] representing the truncated timestamp. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(java.lang.String fieldName, java.lang.String granularity, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates a timestamp to a specified granularity in a given - * timezone. - * - * ```kotlin - * // Truncate the 'createdAt' timestamp to the beginning of the day in timezone specified by - * // the 'tz' field. - * timestampTruncateWithTimezone("createdAt", field("granularity"), field("tz")) - * ``` - * - * @param fieldName The name of the field containing the timestamp. - * @param granularity The granularity expression to truncate to. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone expression to use for truncation. Valid values are from the TZ - * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". - * @return A new [Expression] representing the truncated timestamp. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression granularity, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the difference between two timestamps. - * - * ```kotlin - * // Calculate the difference between the fields 'endAt' and the field 'startAt' in unit specified by - * // the 'unit' field. - * timestampDiff(field("endAt"), field("startAt"), field("unit")) - * ``` - * - * @param end The ending timestamp expression. - * @param start The starting timestamp expression. - * @param unit The unit of time for the difference. Valid values include "microsecond", - * "millisecond", "second", "minute", "hour" and "day". - * @return A new [Expression] representing the difference. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampDiff(com.google.firebase.firestore.pipeline.Expression end, com.google.firebase.firestore.pipeline.Expression start, com.google.firebase.firestore.pipeline.Expression unit) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the difference between two timestamps. - * - * ```kotlin - * // Calculate the difference in days between 'endAt' field and 'startAt' field. - * timestampDiff(field("endAt"), field("startAt"), "day") - * ``` - * - * @param end The ending timestamp expression. - * @param start The starting timestamp expression. - * @param unit The unit of time for the difference. Valid values include "microsecond", - * "millisecond", "second", "minute", "hour" and "day". - * @return A new [Expression] representing the difference. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampDiff(com.google.firebase.firestore.pipeline.Expression end, com.google.firebase.firestore.pipeline.Expression start, java.lang.String unit) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the difference between two timestamps. - * - * ```kotlin - * // Calculate the difference in days between 'endAt' and 'startAt'. - * timestampDiff("endAt", "startAt", "day") - * ``` - * - * @param endFieldName The ending timestamp field name. - * @param startFieldName The starting timestamp field name. - * @param unit The unit of time for the difference. Valid values include "microsecond", - * "millisecond", "second", "minute", "hour" and "day". - * @return A new [Expression] representing the difference. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampDiff(java.lang.String endFieldName, java.lang.String startFieldName, java.lang.String unit) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the difference between two timestamps. - * - * ```kotlin - * // Calculate the difference in days between 'endAt' and 'startAt'. - * timestampDiff("endAt", field("startAt"), "day") - * ``` - * - * @param endFieldName The ending timestamp field name. - * @param start The starting timestamp expression. - * @param unit The unit of time for the difference. Valid values include "microsecond", - * "millisecond", "second", "minute", "hour" and "day". - * @return A new [Expression] representing the difference. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampDiff(java.lang.String endFieldName, com.google.firebase.firestore.pipeline.Expression start, java.lang.String unit) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the difference between two timestamps. - * - * ```kotlin - * // Calculate the difference in days between 'endAt' and 'startAt'. - * timestampDiff(field("endAt"), "startAt", "day") - * ``` - * - * @param end The ending timestamp expression. - * @param startFieldName The starting timestamp field name. - * @param unit The unit of time for the difference. Valid values include "microsecond", - * "millisecond", "second", "minute", "hour" and "day". - * @return A new [Expression] representing the difference. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampDiff(com.google.firebase.firestore.pipeline.Expression end, java.lang.String startFieldName, java.lang.String unit) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that extracts a specified part from a timestamp. - * - * ```kotlin - * // Extract the part specified by the field 'part' from 'createdAt'. - * timestampExtract(field("createdAt"), field("part")) - * ``` - * - * @param timestamp The timestamp expression. - * @param part The part to extract from the timestamp. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", - * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", - * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". - * @return A new [Expression] representing the extracted part. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampExtract(com.google.firebase.firestore.pipeline.Expression timestamp, com.google.firebase.firestore.pipeline.Expression part) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that extracts a specified part from a timestamp. - * - * ```kotlin - * // Extract the day from the timestamp returned by the expression. - * timestampExtract(field("createdAt"), "day") - * ``` - * - * @param timestamp The timestamp expression. - * @param part The part to extract from the timestamp. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", - * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", - * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". - * @return A new [Expression] representing the extracted part. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampExtract(com.google.firebase.firestore.pipeline.Expression timestamp, java.lang.String part) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that extracts a specified part from a timestamp. - * - * ```kotlin - * // Extract the part specified by the field 'part' from 'createdAt'. - * timestampExtract("createdAt", field("part")) - * ``` - * - * @param fieldName The name of the field containing the timestamp. - * @param part The part to extract from the timestamp. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", - * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", - * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". - * @return A new [Expression] representing the extracted part. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampExtract(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression part) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that extracts a specified part from a timestamp. - * - * ```kotlin - * // Extract the day from the timestamp in the 'createdAt' field. - * timestampExtract("createdAt", "day") - * ``` - * - * @param fieldName The name of the field containing the timestamp. - * @param part The part to extract from the timestamp. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", - * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", - * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". - * @return A new [Expression] representing the extracted part. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampExtract(java.lang.String fieldName, java.lang.String part) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that extracts a specified part from a timestamp in a given timezone. - * - * ```kotlin - * // Extract the part specified by the field 'part' from 'createdAt' in the timezone specified by - * // the field 'tz'. - * timestampExtractWithTimezone(field("createdAt"), field("part"), field("tz")) - * ``` - * - * @param timestamp The timestamp expression. - * @param part The part to extract from the timestamp. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", - * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", - * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone expression to use for extraction.Valid values are from the TZ - * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not - * specified. - * @return A new [Expression] representing the extracted part. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(com.google.firebase.firestore.pipeline.Expression timestamp, com.google.firebase.firestore.pipeline.Expression part, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that extracts a specified part from a timestamp in a given timezone. - * - * ```kotlin - * // Extract the part specified by the field 'part' from 'createdAt' in the timezone "America/Los_Angeles". - * timestampExtractWithTimezone(field("createdAt"), field("part"), "America/Los_Angeles") - * ``` - * - * @param timestamp The timestamp expression. - * @param part The part to extract from the timestamp. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", - * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", - * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone expression to use for extraction.Valid values are from the TZ - * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not - * specified. - * @return A new [Expression] representing the extracted part. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(com.google.firebase.firestore.pipeline.Expression timestamp, com.google.firebase.firestore.pipeline.Expression part, java.lang.String timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that extracts a specified part from a timestamp in a given timezone. - * - * ```kotlin - * // Extract the day from the timestamp in the 'createdAt' field in the timezone "America/Los_Angeles". - * timestampExtractWithTimezone(field("createdAt"), "day", "America/Los_Angeles") - * ``` - * - * @param timestamp The timestamp expression. - * @param part The part to extract from the timestamp. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", - * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", - * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone expression to use for extraction.Valid values are from the TZ - * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not - * specified. - * @return A new [Expression] representing the extracted part. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(com.google.firebase.firestore.pipeline.Expression timestamp, java.lang.String part, java.lang.String timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that extracts a specified part from a timestamp in a given timezone. - * - * ```kotlin - * // Extract the part specified by the field 'part' from 'createdAt' in the timezone "America/Los_Angeles". - * timestampExtractWithTimezone("createdAt", field("part"), "America/Los_Angeles") - * ``` - * - * @param fieldName The name of the field containing the timestamp. - * @param part The part to extract from the timestamp. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", - * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", - * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone expression to use for extraction.Valid values are from the TZ - * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not - * specified. - * @return A new [Expression] representing the extracted part. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression part, java.lang.String timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that extracts a specified part from a timestamp in a given timezone. - * - * ```kotlin - * // Extract the day from the timestamp in the 'createdAt' field in the timezone "America/Los_Angeles". - * timestampExtractWithTimezone("createdAt", "day", "America/Los_Angeles") - * ``` - * - * @param fieldName The name of the field containing the timestamp. - * @param part The part to extract from the timestamp. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", - * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", - * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone expression to use for extraction.Valid values are from the TZ - * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not - * specified. - * @return A new [Expression] representing the extracted part. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(java.lang.String fieldName, java.lang.String part, java.lang.String timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that extracts a specified part from a timestamp in a given timezone. - * - * ```kotlin - * // Extract the day from the timestamp in the 'createdAt' field in the timezone specified by the 'tz' field. - * timestampExtractWithTimezone(field("createdAt"), "day", field("tz")) - * ``` - * - * @param timestamp The timestamp expression. - * @param part The part to extract from the timestamp. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", - * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", - * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone expression to use for extraction.Valid values are from the TZ - * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not - * specified. - * @return A new [Expression] representing the extracted part. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(com.google.firebase.firestore.pipeline.Expression timestamp, java.lang.String part, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that extracts a specified part from a timestamp in a given timezone. - * - * ```kotlin - * // Extract the part specified by the field 'part' from 'createdAt' in the timezone specified by the 'tz' field. - * timestampExtractWithTimezone("createdAt", field("part"), field("tz")) - * ``` - * - * @param fieldName The name of the field containing the timestamp. - * @param part The part to extract from the timestamp. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", - * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", - * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone expression to use for extraction.Valid values are from the TZ - * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not - * specified. - * @return A new [Expression] representing the extracted part. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression part, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that extracts a specified part from a timestamp in a given timezone. - * - * ```kotlin - * // Extract the day from the timestamp in the 'createdAt' field in the timezone specified by the 'tz' field. - * timestampExtractWithTimezone("createdAt", "day", field("tz")) - * ``` - * - * @param fieldName The name of the field containing the timestamp. - * @param part The part to extract from the timestamp. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", - * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", - * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone expression to use for extraction.Valid values are from the TZ - * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not - * specified. - * @return A new [Expression] representing the extracted part. - */ - -public static final com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(java.lang.String fieldName, java.lang.String part, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if two expressions are equal. - * - * ```kotlin - * // Check if the 'age' field is equal to an expression - * equal(field("age"), field("minAge").add(10)) - * ``` - * - * @param left The first expression to compare. - * @param right The second expression to compare to. - * @return A new [BooleanExpression] representing the equality comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression equal(com.google.firebase.firestore.pipeline.Expression left, com.google.firebase.firestore.pipeline.Expression right) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if an expression is equal to a value. - * - * ```kotlin - * // Check if the 'age' field is equal to 21 - * equal(field("age"), 21) - * ``` - * - * @param left The first expression to compare. - * @param right The value to compare to. - * @return A new [BooleanExpression] representing the equality comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression equal(com.google.firebase.firestore.pipeline.Expression left, java.lang.Object right) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field's value is equal to an expression. - * - * ```kotlin - * // Check if the 'age' field is equal to the 'limit' field - * equal("age", field("limit")) - * ``` - * - * @param fieldName The field name to compare. - * @param expression The expression to compare to. - * @return A new [BooleanExpression] representing the equality comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression equal(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field's value is equal to another value. - * - * ```kotlin - * // Check if the 'city' field is equal to string constant "London" - * equal("city", "London") - * ``` - * - * @param fieldName The field name to compare. - * @param value The value to compare to. - * @return A new [BooleanExpression] representing the equality comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression equal(java.lang.String fieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if two expressions are not equal. - * - * ```kotlin - * // Check if the 'status' field is not equal to the value of the 'otherStatus' field - * notEqual(field("status"), field("otherStatus")) - * ``` - * - * @param left The first expression to compare. - * @param right The second expression to compare to. - * @return A new [BooleanExpression] representing the inequality comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression notEqual(com.google.firebase.firestore.pipeline.Expression left, com.google.firebase.firestore.pipeline.Expression right) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if an expression is not equal to a value. - * - * ```kotlin - * // Check if the 'status' field is not equal to "completed" - * notEqual(field("status"), "completed") - * ``` - * - * @param left The first expression to compare. - * @param right The value to compare to. - * @return A new [BooleanExpression] representing the inequality comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression notEqual(com.google.firebase.firestore.pipeline.Expression left, java.lang.Object right) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field's value is not equal to an expression. - * - * ```kotlin - * // Check if the 'status' field is not equal to the value of the 'otherStatus' field - * notEqual("status", field("otherStatus")) - * ``` - * - * @param fieldName The field name to compare. - * @param expression The expression to compare to. - * @return A new [BooleanExpression] representing the inequality comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression notEqual(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field's value is not equal to another value. - * - * ```kotlin - * // Check if the 'status' field is not equal to "completed" - * notEqual("status", "completed") - * - * // Check if the 'country' field is not equal to "USA" - * notEqual("country", "USA") - * ``` - * - * @param fieldName The field name to compare. - * @param value The value to compare to. - * @return A new [BooleanExpression] representing the inequality comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression notEqual(java.lang.String fieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if the first expression is greater than the second - * expression. - * - * ```kotlin - * // Check if the 'age' field is greater than the 'limit' field - * greaterThan(field("age"), field("limit")) - * ``` - * - * @param left The first expression to compare. - * @param right The second expression to compare to. - * @return A new [BooleanExpression] representing the greater than comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression greaterThan(com.google.firebase.firestore.pipeline.Expression left, com.google.firebase.firestore.pipeline.Expression right) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if an expression is greater than a value. - * - * ```kotlin - * // Check if the 'price' field is greater than 100 - * greaterThan(field("price"), 100) - * ``` - * - * @param left The first expression to compare. - * @param right The value to compare to. - * @return A new [BooleanExpression] representing the greater than comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression greaterThan(com.google.firebase.firestore.pipeline.Expression left, java.lang.Object right) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field's value is greater than an expression. - * - * ```kotlin - * // Check if the 'age' field is greater than the 'limit' field - * greaterThan("age", field("limit")) - * ``` - * - * @param fieldName The field name to compare. - * @param expression The expression to compare to. - * @return A new [BooleanExpression] representing the greater than comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression greaterThan(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field's value is greater than another value. - * - * ```kotlin - * // Check if the 'price' field is greater than 100 - * greaterThan("price", 100) - * ``` - * - * @param fieldName The field name to compare. - * @param value The value to compare to. - * @return A new [BooleanExpression] representing the greater than comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression greaterThan(java.lang.String fieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if the first expression is greater than or equal to the - * second expression. - * - * ```kotlin - * // Check if the 'quantity' field is greater than or equal to field 'requirement' plus 1 - * greaterThanOrEqual(field("quantity"), field("requirement").add(1)) - * ``` - * - * @param left The first expression to compare. - * @param right The second expression to compare to. - * @return A new [BooleanExpression] representing the greater than or equal to comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression greaterThanOrEqual(com.google.firebase.firestore.pipeline.Expression left, com.google.firebase.firestore.pipeline.Expression right) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if an expression is greater than or equal to a value. - * - * ```kotlin - * // Check if the 'score' field is greater than or equal to 80 - * greaterThanOrEqual(field("score"), 80) - * ``` - * - * @param left The first expression to compare. - * @param right The value to compare to. - * @return A new [BooleanExpression] representing the greater than or equal to comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression greaterThanOrEqual(com.google.firebase.firestore.pipeline.Expression left, java.lang.Object right) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field's value is greater than or equal to an - * expression. - * - * ```kotlin - * // Check if the 'quantity' field is greater than or equal to field 'requirement' plus 1 - * greaterThanOrEqual("quantity", field("requirement").add(1)) - * ``` - * - * @param fieldName The field name to compare. - * @param expression The expression to compare to. - * @return A new [BooleanExpression] representing the greater than or equal to comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression greaterThanOrEqual(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field's value is greater than or equal to another - * value. - * - * ```kotlin - * // Check if the 'score' field is greater than or equal to 80 - * greaterThanOrEqual("score", 80) - * ``` - * - * @param fieldName The field name to compare. - * @param value The value to compare to. - * @return A new [BooleanExpression] representing the greater than or equal to comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression greaterThanOrEqual(java.lang.String fieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if the first expression is less than the second expression. - * - * ```kotlin - * // Check if the 'age' field is less than 'limit' - * lessThan(field("age"), field("limit")) - * ``` - * - * @param left The first expression to compare. - * @param right The second expression to compare to. - * @return A new [BooleanExpression] representing the less than comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression lessThan(com.google.firebase.firestore.pipeline.Expression left, com.google.firebase.firestore.pipeline.Expression right) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if an expression is less than a value. - * - * ```kotlin - * // Check if the 'price' field is less than 50 - * lessThan(field("price"), 50) - * ``` - * - * @param left The first expression to compare. - * @param right The value to compare to. - * @return A new [BooleanExpression] representing the less than comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression lessThan(com.google.firebase.firestore.pipeline.Expression left, java.lang.Object right) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field's value is less than an expression. - * - * ```kotlin - * // Check if the 'age' field is less than 'limit' - * lessThan("age", field("limit")) - * ``` - * - * @param fieldName The field name to compare. - * @param expression The expression to compare to. - * @return A new [BooleanExpression] representing the less than comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression lessThan(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field's value is less than another value. - * - * ```kotlin - * // Check if the 'price' field is less than 50 - * lessThan("price", 50) - * ``` - * - * @param fieldName The field name to compare. - * @param value The value to compare to. - * @return A new [BooleanExpression] representing the less than comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression lessThan(java.lang.String fieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if the first expression is less than or equal to the second - * expression. - * - * ```kotlin - * // Check if the 'quantity' field is less than or equal to 20 - * lessThanOrEqual(field("quantity"), constant(20)) - * ``` - * - * @param left The first expression to compare. - * @param right The second expression to compare to. - * @return A new [BooleanExpression] representing the less than or equal to comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression lessThanOrEqual(com.google.firebase.firestore.pipeline.Expression left, com.google.firebase.firestore.pipeline.Expression right) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if an expression is less than or equal to a value. - * - * ```kotlin - * // Check if the 'score' field is less than or equal to 70 - * lessThanOrEqual(field("score"), 70) - * ``` - * - * @param left The first expression to compare. - * @param right The value to compare to. - * @return A new [BooleanExpression] representing the less than or equal to comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression lessThanOrEqual(com.google.firebase.firestore.pipeline.Expression left, java.lang.Object right) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field's value is less than or equal to an expression. - * - * ```kotlin - * // Check if the 'quantity' field is less than or equal to 20 - * lessThanOrEqual("quantity", constant(20)) - * ``` - * - * @param fieldName The field name to compare. - * @param expression The expression to compare to. - * @return A new [BooleanExpression] representing the less than or equal to comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression lessThanOrEqual(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field's value is less than or equal to another value. - * - * ```kotlin - * // Check if the 'score' field is less than or equal to 70 - * lessThanOrEqual("score", 70) - * ``` - * - * @param fieldName The field name to compare. - * @param value The value to compare to. - * @return A new [BooleanExpression] representing the less than or equal to comparison. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression lessThanOrEqual(java.lang.String fieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that concatenates strings, arrays, or blobs. Types cannot be mixed. - * - * ```kotlin - * // Concatenate the 'firstName' and 'lastName' fields with a space in between. - * concat(field("firstName"), " ", field("lastName")) - * ``` - * - * @param first The first expression to concatenate. - * @param second The second expression to concatenate. - * @param others Additional expressions to concatenate. - * @return A new [Expression] representing the concatenation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression concat(com.google.firebase.firestore.pipeline.Expression first, com.google.firebase.firestore.pipeline.Expression second, java.lang.Object... others) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that concatenates strings, arrays, or blobs. Types cannot be mixed. - * - * ```kotlin - * // Concatenate a field with a literal string. - * concat(field("firstName"), "Doe") - * ``` - * - * @param first The first expression to concatenate. - * @param second The second value to concatenate. - * @param others Additional values to concatenate. - * @return A new [Expression] representing the concatenation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression concat(com.google.firebase.firestore.pipeline.Expression first, java.lang.Object second, java.lang.Object... others) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that concatenates strings, arrays, or blobs. Types cannot be mixed. - * - * ```kotlin - * // Concatenate a field name with an expression. - * concat("firstName", field("lastName")) - * ``` - * - * @param first The name of the field containing the first value to concatenate. - * @param second The second expression to concatenate. - * @param others Additional expressions to concatenate. - * @return A new [Expression] representing the concatenation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression concat(java.lang.String first, com.google.firebase.firestore.pipeline.Expression second, java.lang.Object... others) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that concatenates strings, arrays, or blobs. Types cannot be mixed. - * - * ```kotlin - * // Concatenate a field name with a literal string. - * concat("firstName", "Doe") - * ``` - * - * @param first The name of the field containing the first value to concatenate. - * @param second The second value to concatenate. - * @param others Additional values to concatenate. - * @return A new [Expression] representing the concatenation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression concat(java.lang.String first, java.lang.Object second, java.lang.Object... others) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that creates a Firestore array value from an input array. - * - * ```kotlin - * // Create an array of numbers - * array(1, 2, 3) - * - * // Create an array containing a field value and a constant - * array(field("quantity"), 10) - * ``` - * - * @param elements The input array to evaluate in the expression. - * @return A new [Expression] representing the array function. - */ - -public static final com.google.firebase.firestore.pipeline.Expression array(java.lang.Object... elements) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that creates a Firestore array value from an input array. - * - * @param elements The input array to evaluate in the expression. - * @return A new [Expression] representing the array function. - */ - -public static final com.google.firebase.firestore.pipeline.Expression array(java.util.List elements) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that concatenates an array with other arrays. - * - * ```kotlin - * // Combine the 'items' array with another array field. - * arrayConcat(field("items"), field("otherItems")) - * ``` - * - * @param firstArray The first array expression to concatenate to. - * @param secondArray An expression that evaluates to array to concatenate. - * @param otherArrays Optional additional array expressions or array literals to concatenate. - * @return A new [Expression] representing the arrayConcat operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayConcat(com.google.firebase.firestore.pipeline.Expression firstArray, com.google.firebase.firestore.pipeline.Expression secondArray, java.lang.Object... otherArrays) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that concatenates an array with other arrays. - * - * ```kotlin - * // Combine the 'items' array with another array field. - * arrayConcat(field("items"), field("otherItems")) - * ``` - * - * @param firstArray The first array expression to concatenate to. - * @param secondArray An array expression or array literal to concatenate. - * @param otherArrays Optional additional array expressions or array literals to concatenate. - * @return A new [Expression] representing the arrayConcat operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayConcat(com.google.firebase.firestore.pipeline.Expression firstArray, java.lang.Object secondArray, java.lang.Object... otherArrays) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that concatenates a field's array value with other arrays. - * - * ```kotlin - * // Combine the 'items' array with another array field. - * arrayConcat("items", field("otherItems")) - * ``` - * - * @param firstArrayField The name of field that contains first array to concatenate to. - * @param secondArray An expression that evaluates to array to concatenate. - * @param otherArrays Optional additional array expressions or array literals to concatenate. - * @return A new [Expression] representing the arrayConcat operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayConcat(java.lang.String firstArrayField, com.google.firebase.firestore.pipeline.Expression secondArray, java.lang.Object... otherArrays) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that concatenates a field's array value with other arrays. - * - * ```kotlin - * // Combine the 'items' array with a literal array. - * arrayConcat("items", listOf("a", "b")) - * ``` - * - * @param firstArrayField The name of field that contains first array to concatenate to. - * @param secondArray An array expression or array literal to concatenate. - * @param otherArrays Optional additional array expressions or array literals to concatenate. - * @return A new [Expression] representing the arrayConcat operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayConcat(java.lang.String firstArrayField, java.lang.Object secondArray, java.lang.Object... otherArrays) { throw new RuntimeException("Stub!"); } - -/** - * Reverses the order of elements in the [array]. - * - * ```kotlin - * // Reverse the value of the 'myArray' field. - * arrayReverse(field("myArray")) - * ``` - * - * @param array The array expression to reverse. - * @return A new [Expression] representing the arrayReverse operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayReverse(com.google.firebase.firestore.pipeline.Expression array) { throw new RuntimeException("Stub!"); } - -/** - * Reverses the order of elements in the array field. - * - * ```kotlin - * // Reverse the value of the 'myArray' field. - * arrayReverse("myArray") - * ``` - * - * @param arrayFieldName The name of field that contains the array to reverse. - * @return A new [Expression] representing the arrayReverse operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayReverse(java.lang.String arrayFieldName) { throw new RuntimeException("Stub!"); } - -/** - * Filters an [array] expression based on a predicate. - * - * ```kotlin - * // Filter 'scores' array to include only values greater than 50 - * arrayFilter(field("scores"), "score", greaterThan(variable("score"), 50)) - * ``` - * - * @param array The array expression to filter. - * @param alias The alias to use for the current element in the filter expression. - * @param filter The predicate boolean expression used to filter the elements. - * @return A new [Expression] representing the arrayFilter operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayFilter(com.google.firebase.firestore.pipeline.Expression array, java.lang.String alias, com.google.firebase.firestore.pipeline.BooleanExpression filter) { throw new RuntimeException("Stub!"); } - -/** - * Filters an array field based on a predicate. - * - * ```kotlin - * // Filter 'scores' array to include only values greater than 50 - * arrayFilter("scores", "score", greaterThan(variable("score"), 50)) - * ``` - * - * @param arrayFieldName The name of field that contains array to filter. - * @param alias The alias to use for the current element in the filter expression. - * @param filter The predicate boolean expression used to filter the elements. - * @return A new [Expression] representing the arrayFilter operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayFilter(java.lang.String arrayFieldName, java.lang.String alias, com.google.firebase.firestore.pipeline.BooleanExpression filter) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a provided transformation to each element in an array. - * - * ```kotlin - * // Transform 'scores' array by multiplying each score by 10 - * arrayTransform(field("scores"), "score", multiply(variable("score"), 10)) - * ``` - * - * @param array The array expression to transform. - * @param elementAlias The alias to use for the current element in the transform expression. - * @param transform The expression used to transform the elements. - * @return A new [Expression] representing the arrayTransform operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayTransform(com.google.firebase.firestore.pipeline.Expression array, java.lang.String elementAlias, com.google.firebase.firestore.pipeline.Expression transform) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a provided transformation to each element in an array. - * - * ```kotlin - * // Transform 'scores' array by multiplying each score by 10 - * arrayTransform("scores", "score", multiply(variable("score"), 10)) - * ``` - * - * @param arrayFieldName The name of field that contains array to transform. - * @param elementAlias The alias to use for the current element in the transform expression. - * @param transform The expression used to transform the elements. - * @return A new [Expression] representing the arrayTransform operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayTransform(java.lang.String arrayFieldName, java.lang.String elementAlias, com.google.firebase.firestore.pipeline.Expression transform) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a provided transformation to each element in an array, - * providing the element's index to the transformation expression. - * - * ```kotlin - * // Transform 'scores' array by adding the index - * arrayTransformWithIndex(field("scores"), "score", "i", add(variable("score"), variable("i"))) - * ``` - * - * @param array The array expression to transform. - * @param elementAlias The alias to use for the current element in the transform expression. - * @param indexAlias The alias to use for the current index. - * @param transform The expression used to transform the elements. - * @return A new [Expression] representing the arrayTransformWithIndex operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayTransformWithIndex(com.google.firebase.firestore.pipeline.Expression array, java.lang.String elementAlias, java.lang.String indexAlias, com.google.firebase.firestore.pipeline.Expression transform) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a provided transformation to each element in an array, - * providing the element's index to the transformation expression. - * - * ```kotlin - * // Transform 'scores' array by adding the index - * arrayTransformWithIndex("scores", "score", "i", add(variable("score"), variable("i"))) - * ``` - * - * @param arrayFieldName The name of field that contains array to transform. - * @param elementAlias The alias to use for the current element in the transform expression. - * @param indexAlias The alias to use for the current index. - * @param transform The expression used to transform the elements. - * @return A new [Expression] representing the arrayTransformWithIndex operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayTransformWithIndex(java.lang.String arrayFieldName, java.lang.String elementAlias, java.lang.String indexAlias, com.google.firebase.firestore.pipeline.Expression transform) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a slice of an [array] expression to its end. - * - * ```kotlin - * // Get elements from the 'items' array starting from index 2 - * arraySliceToEnd(field("items"), 2) - * ``` - * - * @param array The array expression. - * @param offset The starting index. - * @return A new [Expression] representing the arraySliceToEnd operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arraySliceToEnd(com.google.firebase.firestore.pipeline.Expression array, int offset) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a slice of an [array] expression to its end. - * - * ```kotlin - * // Get elements from the 'items' array starting at an offset defined by a field - * arraySliceToEnd(field("items"), field("startIdx")) - * ``` - * - * @param array The array expression. - * @param offset The starting index. - * @return A new [Expression] representing the arraySliceToEnd operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arraySliceToEnd(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression offset) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a slice of an array field to its end. - * - * ```kotlin - * // Get elements from the 'items' array starting from index 2 - * arraySliceToEnd("items", 2) - * ``` - * - * @param arrayFieldName The name of field that contains the array. - * @param offset The starting index. - * @return A new [Expression] representing the arraySliceToEnd operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arraySliceToEnd(java.lang.String arrayFieldName, int offset) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a slice of an array field to its end. - * - * ```kotlin - * // Get elements from the 'items' array starting at an offset defined by a field - * arraySliceToEnd("items", field("startIdx")) - * ``` - * - * @param arrayFieldName The name of field that contains the array. - * @param offset The starting index. - * @return A new [Expression] representing the arraySliceToEnd operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arraySliceToEnd(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression offset) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a slice of an [array] expression. - * - * ```kotlin - * // Get 5 elements from the 'items' array starting from index 2 - * arraySlice(field("items"), 2, 5) - * ``` - * - * @param array The array expression. - * @param offset The starting index. - * @param length The number of elements to return. - * @return A new [Expression] representing the arraySlice operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arraySlice(com.google.firebase.firestore.pipeline.Expression array, int offset, int length) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a slice of an array field. - * - * ```kotlin - * // Get 5 elements from the 'items' array starting from index 2 - * arraySlice("items", 2, 5) - * ``` - * - * @param arrayFieldName The name of field that contains the array. - * @param offset The starting index. - * @param length The number of elements to return. - * @return A new [Expression] representing the arraySlice operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arraySlice(java.lang.String arrayFieldName, int offset, int length) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a slice of an [array] expression. - * - * ```kotlin - * // Get elements from the 'items' array using expressions for offset and length - * arraySlice(field("items"), field("startIdx"), field("length")) - * ``` - * - * @param array The array expression. - * @param offset The starting index. - * @param length The number of elements to return. - * @return A new [Expression] representing the arraySlice operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arraySlice(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression offset, com.google.firebase.firestore.pipeline.Expression length) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a slice of an array field. - * - * ```kotlin - * // Get elements from the 'items' array using expressions for offset and length - * arraySlice("items", field("startIdx"), field("length")) - * ``` - * - * @param arrayFieldName The name of field that contains the array. - * @param offset The starting index. - * @param length The number of elements to return. - * @return A new [Expression] representing the arraySlice operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arraySlice(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression offset, com.google.firebase.firestore.pipeline.Expression length) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the sum of the elements in an array. - * - * ```kotlin - * // Get the sum of elements in the 'scores' array. - * arraySum(field("scores")) - * ``` - * - * @param array The array expression to sum. - * @return A new [Expression] representing the sum of the array elements. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arraySum(com.google.firebase.firestore.pipeline.Expression array) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the sum of the elements in an array field. - * - * ```kotlin - * // Get the sum of elements in the 'scores' array. - * arraySum("scores") - * ``` - * - * @param arrayFieldName The name of the field containing the array to sum. - * @return A new [Expression] representing the sum of the array elements. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arraySum(java.lang.String arrayFieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if the array contains a specific [element]. - * - * @param array The array expression to check. - * @param element The element to search for in the array. - * @return A new [BooleanExpression] representing the arrayContains operation. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression arrayContains(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression element) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if the array field contains a specific [element]. - * - * ```kotlin - * // Check if the 'sizes' array contains the value from the 'selectedSize' field - * arrayContains("sizes", field("selectedSize")) - * ``` - * - * @param arrayFieldName The name of field that contains array to check. - * @param element The element to search for in the array. - * @return A new [BooleanExpression] representing the arrayContains operation. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression arrayContains(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression element) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if the [array] contains a specific [element]. - * - * ```kotlin - * // Check if the 'sizes' array contains the value from the 'selectedSize' field - * arrayContains(field("sizes"), field("selectedSize")) - * - * // Check if the 'colors' array contains "red" - * arrayContains(field("colors"), "red") - * ``` - * - * @param array The array expression to check. - * @param element The element to search for in the array. - * @return A new [BooleanExpression] representing the arrayContains operation. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression arrayContains(com.google.firebase.firestore.pipeline.Expression array, java.lang.Object element) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if the array field contains a specific [element]. - * - * ```kotlin - * // Check if the 'colors' array contains "red" - * arrayContains("colors", "red") - * ``` - * - * @param arrayFieldName The name of field that contains array to check. - * @param element The element to search for in the array. - * @return A new [BooleanExpression] representing the arrayContains operation. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression arrayContains(java.lang.String arrayFieldName, java.lang.Object element) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if [array] contains all the specified [values]. - * - * ```kotlin - * // Check if the 'tags' array contains both the value in field "tag1" and the literal value "tag2" - * arrayContainsAll(field("tags"), listOf(field("tag1"), "tag2")) - * ``` - * - * @param array The array expression to check. - * @param values The elements to check for in the array. - * @return A new [BooleanExpression] representing the arrayContainsAll operation. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAll(com.google.firebase.firestore.pipeline.Expression array, java.util.List values) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if [array] contains all elements of [arrayExpression]. - * - * ```kotlin - * // Check if the 'tags' array contains both of the values from field "tag1" and the literal value "tag2" - * arrayContainsAll(field("tags"), array(field("tag1"), "tag2")) - * ``` - * - * @param array The array expression to check. - * @param arrayExpression The elements to check for in the array. - * @return A new [BooleanExpression] representing the arrayContainsAll operation. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAll(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if array field contains all the specified [values]. - * - * ```kotlin - * // Check if the 'tags' array contains both "internal" and "public" - * arrayContainsAll("tags", listOf("internal", "public")) - * ``` - * - * @param arrayFieldName The name of field that contains array to check. - * @param values The elements to check for in the array. - * @return A new [BooleanExpression] representing the arrayContainsAll operation. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAll(java.lang.String arrayFieldName, java.util.List values) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if array field contains all elements of [arrayExpression]. - * - * ```kotlin - * // Check if the 'permissions' array contains all the required permissions - * arrayContainsAll("permissions", field("requiredPermissions")) - * ``` - * - * @param arrayFieldName The name of field that contains array to check. - * @param arrayExpression The elements to check for in the array. - * @return A new [BooleanExpression] representing the arrayContainsAll operation. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAll(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if [array] contains any of the specified [values]. - * - * ```kotlin - * // Check if the 'categories' array contains either values from field "cate1" or "cate2" - * arrayContainsAny(field("categories"), listOf(field("cate1"), field("cate2"))) - * ``` - * - * @param array The array expression to check. - * @param values The elements to check for in the array. - * @return A new [BooleanExpression] representing the arrayContainsAny operation. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAny(com.google.firebase.firestore.pipeline.Expression array, java.util.List values) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if [array] contains any elements of [arrayExpression]. - * - * ```kotlin - * // Check if the 'groups' array contains either the value from the 'userGroup' field - * // or the value "guest" - * arrayContainsAny(field("groups"), array(field("userGroup"), "guest")) - * ``` - * - * @param array The array expression to check. - * @param arrayExpression The elements to check for in the array. - * @return A new [BooleanExpression] representing the arrayContainsAny operation. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAny(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if array field contains any of the specified [values]. - * - * ```kotlin - * // Check if the 'roles' array contains "admin" or "editor" - * arrayContainsAny("roles", listOf("admin", "editor")) - * ``` - * - * @param arrayFieldName The name of field that contains array to check. - * @param values The elements to check for in the array. - * @return A new [BooleanExpression] representing the arrayContainsAny operation. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAny(java.lang.String arrayFieldName, java.util.List values) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if array field contains any elements of [arrayExpression]. - * - * ```kotlin - * // Check if the 'userGroups' array contains any of the 'targetGroups' - * arrayContainsAny("userGroups", field("targetGroups")) - * ``` - * - * @param arrayFieldName The name of field that contains array to check. - * @param arrayExpression The elements to check for in the array. - * @return A new [BooleanExpression] representing the arrayContainsAny operation. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAny(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the length of an [array] expression. - * - * ```kotlin - * // Get the number of items in the 'cart' array - * arrayLength(field("cart")) - * ``` - * - * @param array The array expression to calculate the length of. - * @return A new [Expression] representing the length of the array. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayLength(com.google.firebase.firestore.pipeline.Expression array) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the length of an array field. - * - * ```kotlin - * // Get the number of items in the 'cart' array - * arrayLength("cart") - * ``` - * - * @param arrayFieldName The name of the field containing an array to calculate the length of. - * @return A new [Expression] representing the length of the array. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayLength(java.lang.String arrayFieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first element of an [array] expression. - * - * ```kotlin - * // Get the first element of the 'myArray' field. - * arrayFirst(field("myArray")) - * ``` - * - * @param array The array expression to get the first element from. - * @return A new [Expression] representing the first element. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayFirst(com.google.firebase.firestore.pipeline.Expression array) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first element of an array field. - * - * ```kotlin - * // Get the first element of the 'myArray' field. - * arrayFirst("myArray") - * ``` - * - * @param arrayFieldName The name of the field containing an array to get the first element - * from. - * @return A new [Expression] representing the first element. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayFirst(java.lang.String arrayFieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first `n` elements of an [array] expression. - * - * ```kotlin - * // Get the first 3 elements of the 'myArray' field. - * arrayFirstN(field("myArray"), 3) - * ``` - * - * @param array The array expression. - * @param n The number of elements to return. - * @return A new [Expression] representing the first `n` elements. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayFirstN(com.google.firebase.firestore.pipeline.Expression array, int n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first `n` elements of an [array] expression. - * - * ```kotlin - * // Get the first n elements of the 'myArray' field. - * arrayFirstN(field("myArray"), field("count")) - * ``` - * - * @param array The array expression. - * @param n An expression evaluating to the number of elements to return. - * @return A new [Expression] representing the first `n` elements. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayFirstN(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first `n` elements of an array field. - * - * ```kotlin - * // Get the first n elements of the 'myArray' field. - * arrayFirstN("myArray", field("count")) - * ``` - * - * @param arrayFieldName The name of the field containing an array to get the first `n` elements - * from. - * @param n An expression evaluating to the number of elements to return. - * @return A new [Expression] representing the first `n` elements. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayFirstN(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first `n` elements of an array field. - * - * ```kotlin - * // Get the first n elements of the 'myArray' field. - * arrayFirstN("myArray", 3) - * ``` - * - * @param arrayFieldName The name of the field containing an array to get the first `n` elements - * from. - * @param n The number of elements to return. - * @return A new [Expression] representing the first `n` elements. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayFirstN(java.lang.String arrayFieldName, int n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the last element of an [array] expression. - * - * ```kotlin - * // Get the last element of the 'myArray' field. - * arrayLast(field("myArray")) - * ``` - * - * @param array The array expression to get the last element from. - * @return A new [Expression] representing the last element. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayLast(com.google.firebase.firestore.pipeline.Expression array) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the last element of an array field. - * - * ```kotlin - * // Get the last element of the 'myArray' field. - * arrayLast("myArray") - * ``` - * - * @param arrayFieldName The name of the field containing an array to get the last element from. - * @return A new [Expression] representing the last element. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayLast(java.lang.String arrayFieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the last `n` elements of an [array] expression. - * - * ```kotlin - * // Get the last 3 elements of the 'myArray' field. - * arrayLastN(field("myArray"), 3) - * ``` - * - * @param array The array expression. - * @param n The number of elements to return. - * @return A new [Expression] representing the last `n` elements. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayLastN(com.google.firebase.firestore.pipeline.Expression array, int n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the last `n` elements of an [array] expression. - * - * ```kotlin - * // Get the last n elements of the 'myArray' field. - * arrayLastN(field("myArray"), field("count")) - * ``` - * - * @param array The array expression. - * @param n An expression evaluating to the number of elements to return. - * @return A new [Expression] representing the last `n` elements. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayLastN(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the last `n` elements of an array field. - * - * ```kotlin - * // Get the last n elements of the 'myArray' field. - * arrayLastN("myArray", field("count")) - * ``` - * - * @param arrayFieldName The name of the field containing an array to get the last `n` elements - * from. - * @param n An expression evaluating to the number of elements to return. - * @return A new [Expression] representing the last `n` elements. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayLastN(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the last `n` elements of an array field. - * - * ```kotlin - * // Get the last n elements of the 'myArray' field. - * arrayLastN("myArray", 3) - * ``` - * - * @param arrayFieldName The name of the field containing an array to get the last `n` elements - * from. - * @param n The number of elements to return. - * @return A new [Expression] representing the last `n` elements. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayLastN(java.lang.String arrayFieldName, int n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the minimum element of the [array]. - * - * ```kotlin - * // Get the minimum element of the 'myArray' field. - * arrayMinimum(field("myArray")) - * ``` - * - * @param array The array expression. - * @return A new [Expression] representing the minimum element. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayMinimum(com.google.firebase.firestore.pipeline.Expression array) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the minimum element of an array field. - * - * ```kotlin - * // Get the minimum element of the 'myArray' field. - * arrayMinimum("myArray") - * ``` - * - * @param arrayFieldName The name of the field containing an array to get the minimum element - * from. - * @return A new [Expression] representing the minimum element. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayMinimum(java.lang.String arrayFieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first `n` smallest elements of the [array]. - * - * Note: Returns the n smallest non-null elements in the array, in ascending order. This does - * not use a stable sort, meaning the order of equivalent elements is undefined. - * - * ```kotlin - * // Get the 3 smallest elements of the 'myArray' field. - * arrayMinimumN(field("myArray"), 3) - * ``` - * - * @param array The array expression. - * @param n The number of elements to return. - * @return A new [Expression] representing the first `n` smallest elements. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayMinimumN(com.google.firebase.firestore.pipeline.Expression array, int n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first `n` smallest elements of the [array]. - * - * Note: Returns the n smallest non-null elements in the array, in ascending order. This does - * not use a stable sort, meaning the order of equivalent elements is undefined. - * - * ```kotlin - * // Get the n smallest elements of the 'myArray' field. - * arrayMinimumN(field("myArray"), field("count")) - * ``` - * - * @param array The array expression. - * @param n An expression evaluating to the number of elements to return. - * @return A new [Expression] representing the first `n` smallest elements. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayMinimumN(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first `n` smallest elements of the [array]. - * - * Note: Returns the n smallest non-null elements in the array, in ascending order. This does - * not use a stable sort, meaning the order of equivalent elements is undefined. - * - * ```kotlin - * // Get the n smallest elements of the 'myArray' field. - * arrayMinimumN("myArray", field("count")) - * ``` - * - * @param arrayFieldName The name of the field containing an array to get the first `n` smallest - * elements from. - * @param n An expression evaluating to the number of elements to return. - * @return A new [Expression] representing the first `n` smallest elements. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayMinimumN(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first `n` smallest elements of the [array]. - * - * Note: Returns the n smallest non-null elements in the array, in ascending order. This does - * not use a stable sort, meaning the order of equivalent elements is undefined. - * - * ```kotlin - * // Get the 3 smallest elements of the 'myArray' field. - * arrayMinimumN("myArray", 3) - * ``` - * - * @param arrayFieldName The name of the field containing an array to get the first `n` smallest - * elements from. - * @param n The number of elements to return. - * @return A new [Expression] representing the first `n` smallest elements. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayMinimumN(java.lang.String arrayFieldName, int n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the maximum element of the [array]. - * - * ```kotlin - * // Get the maximum element of the 'myArray' field. - * arrayMaximum(field("myArray")) - * ``` - * - * @param array The array expression. - * @return A new [Expression] representing the maximum element. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayMaximum(com.google.firebase.firestore.pipeline.Expression array) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the maximum element of an array field. - * - * ```kotlin - * // Get the maximum element of the 'myArray' field. - * arrayMaximum("myArray") - * ``` - * - * @param arrayFieldName The name of the field containing an array to get the maximum element - * from. - * @return A new [Expression] representing the maximum element. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayMaximum(java.lang.String arrayFieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first `n` largest elements of the [array]. - * - * Note: Returns the n largest non-null elements in the array, in descending order. This does - * not use a stable sort, meaning the order of equivalent elements is undefined. - * - * ```kotlin - * // Get the 3 largest elements of the 'myArray' field. - * arrayMaximumN(field("myArray"), 3) - * ``` - * - * @param array The array expression. - * @param n The number of elements to return. - * @return A new [Expression] representing the first `n` largest elements. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayMaximumN(com.google.firebase.firestore.pipeline.Expression array, int n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first `n` largest elements of the [array]. - * - * Note: Returns the n largest non-null elements in the array, in descending order. This does - * not use a stable sort, meaning the order of equivalent elements is undefined. - * - * ```kotlin - * // Get the n largest elements of the 'myArray' field. - * arrayMaximumN(field("myArray"), field("count")) - * ``` - * - * @param array The array expression. - * @param n An expression evaluating to the number of elements to return. - * @return A new [Expression] representing the first `n` largest elements. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayMaximumN(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first `n` largest elements of the [array]. - * - * Note: Returns the n largest non-null elements in the array, in descending order. This does - * not use a stable sort, meaning the order of equivalent elements is undefined. - * - * ```kotlin - * // Get the 3 largest elements of the 'myArray' field. - * arrayMaximumN("myArray", 3) - * ``` - * - * @param arrayFieldName The name of the field containing an array to get the first `n` largest - * elements from. - * @param n The number of elements to return. - * @return A new [Expression] representing the first `n` largest elements. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayMaximumN(java.lang.String arrayFieldName, int n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first `n` largest elements of the [array]. - * - * Note: Returns the n largest non-null elements in the array, in descending order. This does - * not use a stable sort, meaning the order of equivalent elements is undefined. - * - * ```kotlin - * // Get the n largest elements of the 'myArray' field. - * arrayMaximumN("myArray", field("count")) - * ``` - * - * @param arrayFieldName The name of the field containing an array to get the first `n` largest - * elements from. - * @param n An expression evaluating to the number of elements to return. - * @return A new [Expression] representing the first `n` largest elements. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayMaximumN(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the index of the first occurrence of the specified [value] - * in the [array], or -1 if the value is not found. - * - * ```kotlin - * // Get the index of 'foo' in the 'tags' array field. - * arrayIndexOf(field("tags"), "foo") - * ``` - * - * @param array The array expression. - * @param value The value to search for. - * @return A new [Expression] representing the index of the value. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayIndexOf(com.google.firebase.firestore.pipeline.Expression array, java.lang.Object value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the index of the first occurrence of the specified [value] - * in the [array], or -1 if the value is not found. - * - * ```kotlin - * // Get the index of 'foo' in the 'tags' array field. - * arrayIndexOf(field("tags"), "foo") - * ``` - * - * @param arrayFieldName The name of the field containing an array to get the index of the value - * from. - * @param value The value to search for. - * @return A new [Expression] representing the index of the value. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayIndexOf(java.lang.String arrayFieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the index of the last occurrence of the specified [value] - * in the [array], or -1 if the value is not found. - * - * ```kotlin - * // Get the last index of 'foo' in the 'tags' array field. - * arrayLastIndexOf(field("tags"), "foo") - * ``` - * - * @param array The array expression. - * @param value The value to search for. - * @return A new [Expression] representing the last index of the value. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayLastIndexOf(com.google.firebase.firestore.pipeline.Expression array, java.lang.Object value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the index of the last occurrence of the specified [value] - * in the [array], or -1 if the value is not found. - * - * ```kotlin - * // Get the last index of 'foo' in the 'tags' array field. - * arrayLastIndexOf(field("tags"), "foo") - * ``` - * - * @param arrayFieldName The name of the field containing an array to get the last index of the - * value from. - * @param value The value to search for. - * @return A new [Expression] representing the last index of the value. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayLastIndexOf(java.lang.String arrayFieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a list of all indices where the specified [value] occurs - * in the [array]. - * - * ```kotlin - * // Get all indices of 'foo' in the 'tags' array field. - * arrayIndexOfAll(field("tags"), "foo") - * ``` - * - * @param array The array expression. - * @param value The value to search for. - * @return A new [Expression] representing the list of indices. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayIndexOfAll(com.google.firebase.firestore.pipeline.Expression array, java.lang.Object value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a list of all indices where the specified [value] occurs - * in the [array]. - * - * ```kotlin - * // Get all indices of 'foo' in the 'tags' array field. - * arrayIndexOfAll(field("tags"), "foo") - * ``` - * - * @param arrayFieldName The name of the field containing an array to get the indices of the - * value from. - * @param value The value to search for. - * @return A new [Expression] representing the list of indices. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayIndexOfAll(java.lang.String arrayFieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that indexes into an array from the beginning or end and return the - * element. If the offset exceeds the array length, an error is returned. A negative offset, - * starts from the end. - * - * ```kotlin - * // Return the value in the tags field array at index specified by field 'favoriteTag'. - * arrayGet(field("tags"), field("favoriteTag")) - * ``` - * - * @param array An [Expression] evaluating to an array. - * @param offset An Expression evaluating to the index of the element to return. - * @return A new [Expression] representing the arrayOffset operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayGet(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression offset) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that indexes into an array from the beginning or end and return the - * element. If the offset exceeds the array length, an error is returned. A negative offset, - * starts from the end. - * - * ```kotlin - * // Return the value in the 'tags' field array at index `1`. - * arrayGet(field("tags"), 1) - * ``` - * - * @param array An [Expression] evaluating to an array. - * @param offset The index of the element to return. - * @return A new [Expression] representing the arrayOffset operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayGet(com.google.firebase.firestore.pipeline.Expression array, int offset) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that indexes into an array from the beginning or end and return the - * element. If the offset exceeds the array length, an error is returned. A negative offset, - * starts from the end. - * - * ```kotlin - * // Return the value in the tags field array at index specified by field 'favoriteTag'. - * arrayGet("tags", field("favoriteTag")) - * ``` - * - * @param arrayFieldName The name of an array field. - * @param offset An Expression evaluating to the index of the element to return. - * @return A new [Expression] representing the arrayOffset operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayGet(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression offset) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that indexes into an array from the beginning or end and return the - * element. If the offset exceeds the array length, an error is returned. A negative offset, - * starts from the end. - * - * ```kotlin - * // Return the value in the 'tags' field array at index `1`. - * arrayGet("tags", 1) - * ``` - * - * @param arrayFieldName The name of an array field. - * @param offset The index of the element to return. - * @return A new [Expression] representing the arrayOffset operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression arrayGet(java.lang.String arrayFieldName, int offset) { throw new RuntimeException("Stub!"); } - -/** - * Creates a conditional expression that evaluates to a [thenExpr] expression if a condition is - * true or an [elseExpr] expression if the condition is false. - * - * @param condition The condition to evaluate. - * @param thenExpr The expression to evaluate if the condition is true. - * @param elseExpr The expression to evaluate if the condition is false. - * @return A new [Expression] representing the conditional operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression conditional(com.google.firebase.firestore.pipeline.BooleanExpression condition, com.google.firebase.firestore.pipeline.Expression thenExpr, com.google.firebase.firestore.pipeline.Expression elseExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates a conditional expression that evaluates to a [thenValue] if a condition is true or an - * [elseValue] if the condition is false. - * - * ```kotlin - * // If the 'quantity' field is greater than 10, return "High", otherwise return "Low" - * conditional(field("quantity").greaterThan(10), "High", "Low") - * ``` - * - * @param condition The condition to evaluate. - * @param thenValue Value if the condition is true. - * @param elseValue Value if the condition is false. - * @return A new [Expression] representing the conditional operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression conditional(com.google.firebase.firestore.pipeline.BooleanExpression condition, java.lang.Object thenValue, java.lang.Object elseValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field exists. - * - * @param value An expression evaluates to the name of the field to check. - * @return A new [Expression] representing the exists check. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression exists(com.google.firebase.firestore.pipeline.Expression value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field exists. - * - * @param fieldName The field name to check. - * @return A new [Expression] representing the exists check. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression exists(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [catchExpr] argument if there is an error, else return - * the result of the [tryExpr] argument evaluation. - * - * ```kotlin - * // Returns the first item in the title field arrays, or returns - * // the entire title field if the array is empty or the field is another type. - * ifError(arrayGet(field("title"), 0), field("title")) - * ``` - * - * @param tryExpr The try expression. - * @param catchExpr The catch expression that will be evaluated and returned if the [tryExpr] - * produces an error. - * @return A new [Expression] representing the ifError operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression ifError(com.google.firebase.firestore.pipeline.Expression tryExpr, com.google.firebase.firestore.pipeline.Expression catchExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [catchExpr] argument if there is an error, else return - * the result of the [tryExpr] argument evaluation. - * - * This overload will return [BooleanExpression] when both parameters are also - * [BooleanExpression]. - * - * ```kotlin - * // Returns the result of the boolean expression, or false if it errors. - * ifError(field("is_premium"), false) - * ``` - * - * @param tryExpr The try boolean expression. - * @param catchExpr The catch boolean expression that will be evaluated and returned if the - * [tryExpr] produces an error. - * @return A new [BooleanExpression] representing the ifError operation. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression ifError(com.google.firebase.firestore.pipeline.BooleanExpression tryExpr, com.google.firebase.firestore.pipeline.BooleanExpression catchExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a given expression produces an error. - * - * ```kotlin - * // Check if the result of a calculation is an error - * isError(arrayContains(field("title"), 1)) - * ``` - * - * @param expr The expression to check. - * @return A new [BooleanExpression] representing the `isError` check. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression isError(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [catchValue] argument if there is an error, else - * return the result of the [tryExpr] argument evaluation. - * - * ```kotlin - * // Returns the first item in the title field arrays, or returns "Default Title" - * ifError(arrayGet(field("title"), 0), "Default Title") - * ``` - * - * @param tryExpr The try expression. - * @param catchValue The value that will be returned if the [tryExpr] produces an error. - * @return A new [Expression] representing the ifError operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression ifError(com.google.firebase.firestore.pipeline.Expression tryExpr, java.lang.Object catchValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [elseExpr] argument if [ifExpr] is absent, else return - * the result of the [ifExpr] argument evaluation. - * - * ```kotlin - * // Returns the value of the optional field 'optional_field', or returns 'default_value' - * // if the field is absent. - * ifAbsent(field("optional_field"), "default_value") - * ``` - * - * @param ifExpr The expression to check for absence. - * @param elseExpr The expression that will be evaluated and returned if [ifExpr] is absent. - * @return A new [Expression] representing the ifAbsent operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression ifAbsent(com.google.firebase.firestore.pipeline.Expression ifExpr, com.google.firebase.firestore.pipeline.Expression elseExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [elseValue] argument if [ifExpr] is absent, else - * return the result of the [ifExpr] argument evaluation. - * - * ```kotlin - * // Returns the value of the optional field 'optional_field', or returns 'default_value' - * // if the field is absent. - * ifAbsent(field("optional_field"), "default_value") - * ``` - * - * @param ifExpr The expression to check for absence. - * @param elseValue The value that will be returned if [ifExpr] is absent. - * @return A new [Expression] representing the ifAbsent operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression ifAbsent(com.google.firebase.firestore.pipeline.Expression ifExpr, java.lang.Object elseValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [elseExpr] argument if [ifFieldName] is absent, else - * return the value of the field. - * - * ```kotlin - * // Returns the value of the optional field 'optional_field', or returns the value of - * // 'default_field' if 'optional_field' is absent. - * ifAbsent("optional_field", field("default_field")) - * ``` - * - * @param ifFieldName The field to check for absence. - * @param elseExpr The expression that will be evaluated and returned if [ifFieldName] is - * absent. - * @return A new [Expression] representing the ifAbsent operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression ifAbsent(java.lang.String ifFieldName, com.google.firebase.firestore.pipeline.Expression elseExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [elseValue] argument if [ifFieldName] is absent, else - * return the value of the field. - * - * ```kotlin - * // Returns the value of the optional field 'optional_field', or returns 'default_value' - * // if the field is absent. - * ifAbsent("optional_field", "default_value") - * ``` - * - * @param ifFieldName The field to check for absence. - * @param elseValue The value that will be returned if [ifFieldName] is absent. - * @return A new [Expression] representing the ifAbsent operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression ifAbsent(java.lang.String ifFieldName, java.lang.Object elseValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [elseExpr] argument if [ifExpr] evaluates to null, - * else return the result of the [ifExpr] argument evaluation. - * - * This function provides a fallback for both absent and explicit null values. In contrast, - * [ifAbsent] only triggers for missing fields. - * - * ```kotlin - * // Returns the user's preferred name, or if that is null, returns their full name. - * ifNull(field("preferredName"), field("fullName")) - * ``` - * - * @param ifExpr The expression to check for null. - * @param elseExpr The expression that will be evaluated and returned if [ifExpr] is null. - * @return A new [Expression] representing the ifNull operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression ifNull(com.google.firebase.firestore.pipeline.Expression ifExpr, com.google.firebase.firestore.pipeline.Expression elseExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [elseValue] argument if [ifExpr] evaluates to null, - * else return the result of the [ifExpr] argument evaluation. - * - * This function provides a fallback for both absent and explicit null values. In contrast, - * [ifAbsent] only triggers for missing fields. - * - * ```kotlin - * // Returns the user's display name, or returns "Anonymous" if the field is null. - * ifNull(field("displayName"), "Anonymous") - * ``` - * - * @param ifExpr The expression to check for null. - * @param elseValue The value that will be returned if [ifExpr] evaluates to null. - * @return A new [Expression] representing the ifNull operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression ifNull(com.google.firebase.firestore.pipeline.Expression ifExpr, java.lang.Object elseValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [elseExpr] argument if [ifFieldName] field is null, - * else return the value of the field. - * - * ```kotlin - * // Returns the user's preferred name, or if that is null, returns their full name. - * ifNull("preferredName", field("fullName")) - * ``` - * - * @param ifFieldName The field to check for null. - * @param elseExpr The expression that will be evaluated and returned if [ifFieldName] is null. - * @return A new [Expression] representing the ifNull operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression ifNull(java.lang.String ifFieldName, com.google.firebase.firestore.pipeline.Expression elseExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [elseValue] argument if [ifFieldName] field is null, - * else return the value of the field. - * - * ```kotlin - * // Returns the user's display name, or returns "Anonymous" if the field is null. - * ifNull("displayName", "Anonymous") - * ``` - * - * @param ifFieldName The field to check for null. - * @param elseValue The value that will be returned if [ifFieldName] is null. - * @return A new [Expression] representing the ifNull operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression ifNull(java.lang.String ifFieldName, java.lang.Object elseValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first non-null, non-absent argument, without - * evaluating the rest of the arguments. When all arguments are null or absent, returns the last - * argument. - * - * ```kotlin - * // Returns the value of the first non-null, non-absent field among 'preferredName', 'fullName', - * // or the last argument if all previous fields are null. - * coalesce(field("preferredName"), field("fullName"), constant("Anonymous")) - * ``` - * - * @param expression The first expression to check for null. - * @param replacement The fallback expression or value if the first one is null. - * @param others Optional additional expressions to check if previous ones are null. - * @return A new [Expression] representing the coalesce operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression coalesce(com.google.firebase.firestore.pipeline.Expression expression, java.lang.Object replacement, java.lang.Object... others) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first non-null, non-absent argument, without - * evaluating the rest of the arguments. When all arguments are null or absent, returns the last - * argument. - * - * ```kotlin - * // Returns the value of the first non-null, non-absent field among 'preferredName', 'fullName', - * // or the last argument if all previous fields are null. - * coalesce("preferredName", field("fullName"), constant("Anonymous")) - * ``` - * - * @param fieldName The name of the first field to check for null. - * @param replacement The fallback expression or value if the first one is null. - * @param others Optional additional expressions to check if previous ones are null. - * @return A new [Expression] representing the coalesce operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression coalesce(java.lang.String fieldName, java.lang.Object replacement, java.lang.Object... others) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the collection ID from a path. - * - * ```kotlin - * // Get the collection ID from the 'path' field - * collectionId(field("path")) - * ``` - * - * @param path An expression the evaluates to a path. - * @return A new [Expression] representing the collectionId operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression collectionId(com.google.firebase.firestore.pipeline.Expression path) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the collection ID from a path. - * - * ```kotlin - * // Get the collection ID from a path field - * collectionId("pathField") - * ``` - * - * @param pathField The string representation of the path. - * @return A new [Expression] representing the collectionId operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression collectionId(java.lang.String pathField) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the document ID from a path. - * - * ```kotlin - * // Get the document ID from the 'path' field - * documentId(field("path")) - * ``` - * - * @param documentPath An expression the evaluates to document path. - * @return A new [Expression] representing the documentId operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression documentId(com.google.firebase.firestore.pipeline.Expression documentPath) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the document ID from a path. - * - * ```kotlin - * // Get the document ID from a path string - * documentId("projects/p/databases/d/documents/c/d") - * ``` - * - * @param documentPath The string representation of the document path. - * @return A new [Expression] representing the documentId operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression documentId(java.lang.String documentPath) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the document ID from a [DocumentReference]. - * - * @param docRef The [DocumentReference]. - * @return A new [Expression] representing the documentId operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression documentId(com.google.firebase.firestore.DocumentReference docRef) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the parent document reference of a document reference. - * - * ```kotlin - * // Get the parent document reference of a document reference. - * parent(field("__path__")) - * ``` - * - * @param documentPath An expression evaluating to a document reference. - * @return A new [Expression] representing the parent operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression parent(com.google.firebase.firestore.pipeline.Expression documentPath) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the parent document reference of a document reference. - * - * ```kotlin - * // Get the parent document reference of a document reference. - * parent("projects/p/databases/d/documents/c/d") - * ``` - * - * @param documentPath A string path to get the parent from. - * @return A new [Expression] representing the parent operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression parent(java.lang.String documentPath) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the parent document reference of a document reference. - * - * ```kotlin - * // Get the parent document reference of a document reference. - * parent(myDocumentReference) - * ``` - * - * @param docRef A [DocumentReference] to get the parent from. - * @return A new [Expression] representing the parent operation. - */ - -public static final com.google.firebase.firestore.pipeline.Expression parent(com.google.firebase.firestore.DocumentReference docRef) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that retrieves the value of a variable bound via [Pipeline.define]. - * - * Example: - * ```kotlin - * firestore.pipeline().collection("products") - * .define( - * multiply(field("price"), 0.9).as("discountedPrice"), - * add(field("stock"), 10).as("newStock") - * ) - * .where(lessThan(variable("discountedPrice"), 100)) - * .select(field("name"), variable("newStock")); - * ``` - * - * @param name The name of the variable to retrieve. - * @return An [Expression] representing the variable's value. - */ - -public static final com.google.firebase.firestore.pipeline.Expression variable(java.lang.String name) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that represents the current document being processed. - * - * Example: - * ```kotlin - * // Define the current document as a variable "doc" - * firestore.pipeline().collection("books") - * .define(currentDocument().alias("doc")) - * // Access a field from the defined document variable - * .select(variable("doc").getField("title")) - * ``` - * - * @return An [Expression] representing the current document. - */ - -public static final com.google.firebase.firestore.pipeline.Expression currentDocument() { throw new RuntimeException("Stub!"); } - -/** - * Evaluates to the distance in meters between the location in the specified field and the query - * location. - * - * Note: This Expression can only be used within a `Search` stage. - * - * @example - * ```kotlin - * db.pipeline().collection("restaurants").search( - * SearchStage(query = documentMatches("waffles"), sort = arrayOf(geoDistance("location", GeoPoint(37.0, -122.0)).ascending())) - * ) - * ``` - * - * @param fieldName Specifies the field in the document which contains the first GeoPoint for - * distance computation. - * @param location Compute distance to this GeoPoint. - */ - -public static final com.google.firebase.firestore.pipeline.Expression geoDistance(java.lang.String fieldName, com.google.firebase.firestore.GeoPoint location) { throw new RuntimeException("Stub!"); } - -/** - * Evaluates to the distance in meters between the location in the specified field and the query - * location. - * - * Note: This Expression can only be used within a `Search` stage. - * - * @example - * ```kotlin - * db.pipeline().collection("restaurants").search( - * SearchStage(query = documentMatches("waffles"), sort = arrayOf(geoDistance(field("location"), GeoPoint(37.0, -122.0)).ascending())) - * ) - * ``` - * - * @param field Specifies the field in the document which contains the first GeoPoint for - * distance computation. - * @param location Compute distance to this GeoPoint. - */ - -public static final com.google.firebase.firestore.pipeline.Expression geoDistance(com.google.firebase.firestore.pipeline.Field field, com.google.firebase.firestore.GeoPoint location) { throw new RuntimeException("Stub!"); } - -/** - * Perform a full-text search on all indexed search fields in the document. - * - * Note: This Expression can only be used within a `Search` stage. - * - * @example - * ```kotlin - * db.pipeline().collection("restaurants").search( - * SearchStage(query = documentMatches("waffles OR pancakes")) - * ) - * ``` - * - * @param rquery Define the search query using the search DSL. - */ - -public static final com.google.firebase.firestore.pipeline.BooleanExpression documentMatches(java.lang.String rquery) { throw new RuntimeException("Stub!"); } - -/** - * Evaluates to the search score that reflects the topicality of the document to all of the text - * predicates (for example: `documentMatches`) in the search query. If `SearchStage.query` is - * not set or does not contain any text predicates, then this score will always be `0`. - * - * Note: This Expression can only be used within a `Search` stage. - * @example - * ```kotlin - * db.pipeline().collection("restaurants").search( - * SearchStage(query = documentMatches("waffles"), sort = arrayOf(score().descending())) - * ) - * ``` - */ - -public static final com.google.firebase.firestore.pipeline.Expression score() { throw new RuntimeException("Stub!"); } - -public static final com.google.firebase.firestore.pipeline.Expression.Companion Companion; -static { Companion = null; } -@SuppressWarnings({"unchecked", "deprecation", "all"}) -public static final class Companion { - -Companion() { throw new RuntimeException("Stub!"); } - -/** - * Create a constant for a [String] value. - * - * ```kotlin - * // Create a constant with the value "hello" - * constant("hello") - * ``` - * - * @param value The [String] value. - * @return A new [Expression] constant instance. - */ - -public com.google.firebase.firestore.pipeline.Expression constant(java.lang.String value) { throw new RuntimeException("Stub!"); } - -/** - * Create a constant for a [Number] value. - * - * ```kotlin - * // Create a constant with the value 123 - * constant(123) - * ``` - * - * @param value The [Number] value. - * @return A new [Expression] constant instance. - */ - -public com.google.firebase.firestore.pipeline.Expression constant(java.lang.Number value) { throw new RuntimeException("Stub!"); } - -/** - * Create a constant for a [Date] value. - * - * ```kotlin - * // Create a constant with the current date - * constant(Date()) - * ``` - * - * @param value The [Date] value. - * @return A new [Expression] constant instance. - */ - -public com.google.firebase.firestore.pipeline.Expression constant(java.util.Date value) { throw new RuntimeException("Stub!"); } - -/** - * Create a constant for a [Timestamp] value. - * - * ```kotlin - * // Create a constant with the current timestamp - * constant(Timestamp.now()) - * ``` - * - * @param value The [Timestamp] value. - * @return A new [Expression] constant instance. - */ - -public com.google.firebase.firestore.pipeline.Expression constant(com.google.firebase.Timestamp value) { throw new RuntimeException("Stub!"); } - -/** - * Create a constant for a [Boolean] value. - * - * ```kotlin - * // Create a constant with the value true - * constant(true) - * ``` - * - * @param value The [Boolean] value. - * @return A new [BooleanExpression] constant instance. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression constant(boolean value) { throw new RuntimeException("Stub!"); } - -/** - * Create a constant for a [GeoPoint] value. - * - * ```kotlin - * // Create a constant with a GeoPoint - * constant(GeoPoint(37.7749, -122.4194)) - * ``` - * - * @param value The [GeoPoint] value. - * @return A new [Expression] constant instance. - */ - -public com.google.firebase.firestore.pipeline.Expression constant(com.google.firebase.firestore.GeoPoint value) { throw new RuntimeException("Stub!"); } - -/** - * Create a constant for a bytes value. - * - * ```kotlin - * // Create a constant with a byte array - * constant(byteArrayOf(0x48, 0x65, 0x6c, 0x6c, 0x6f)) // "Hello" - * ``` - * - * @param value The bytes value. - * @return A new [Expression] constant instance. - */ - -public com.google.firebase.firestore.pipeline.Expression constant(byte[] value) { throw new RuntimeException("Stub!"); } - -/** - * Create a constant for a [Blob] value. - * - * ```kotlin - * // Create a constant with a Blob - * constant(Blob.fromBytes(byteArrayOf(0x48, 0x65, 0x6c, 0x6c, 0x6f))) // "Hello" - * ``` - * - * @param value The [Blob] value. - * @return A new [Expression] constant instance. - */ - -public com.google.firebase.firestore.pipeline.Expression constant(com.google.firebase.firestore.Blob value) { throw new RuntimeException("Stub!"); } - -/** - * Create a constant for a [DocumentReference] value. - * - * ```kotlin - * // val firestore = FirebaseFirestore.getInstance() - * // val docRef = firestore.collection("cities").document("SF") - * // constant(docRef) - * ``` - * - * @param ref The [DocumentReference] value. - * @return A new [Expression] constant instance. - */ - -public com.google.firebase.firestore.pipeline.Expression constant(com.google.firebase.firestore.DocumentReference ref) { throw new RuntimeException("Stub!"); } - -/** - * Create a constant for a [VectorValue] value. - * - * ```kotlin - * // Create a constant with a VectorValue - * constant(VectorValue(listOf(1.0, 2.0, 3.0))) - * ``` - * - * @param value The [VectorValue] value. - * @return A new [Expression] constant instance. - */ - -public com.google.firebase.firestore.pipeline.Expression constant(com.google.firebase.firestore.VectorValue value) { throw new RuntimeException("Stub!"); } - -/** - * Constant for a null value. - * - * ```kotlin - * // Create a null constant - * nullValue() - * ``` - * - * @return A [Expression] constant instance. - */ - -public com.google.firebase.firestore.pipeline.Expression nullValue() { throw new RuntimeException("Stub!"); } - -/** - * Create a vector constant for a [DoubleArray] value. - * - * ```kotlin - * // Create a vector constant from a DoubleArray - * vector(doubleArrayOf(1.0, 2.0, 3.0)) - * ``` - * - * @param vector The [DoubleArray] value. - * @return A [Expression] constant instance. - */ - -public com.google.firebase.firestore.pipeline.Expression vector(double[] vector) { throw new RuntimeException("Stub!"); } - -/** - * Create a vector constant for a [VectorValue] value. - * - * ```kotlin - * // Create a vector constant from a VectorValue - * vector(VectorValue(listOf(1.0, 2.0, 3.0))) - * ``` - * - * @param vector The [VectorValue] value. - * @return A [Expression] constant instance. - */ - -public com.google.firebase.firestore.pipeline.Expression vector(com.google.firebase.firestore.VectorValue vector) { throw new RuntimeException("Stub!"); } - -/** - * Creates a [Field] instance representing the field at the given path. - * - * The path can be a simple field name (e.g., "name") or a dot-separated path to a nested field - * (e.g., "address.city"). - * - * @param name The path to the field. - * @return A new [Field] instance representing the specified path. - */ - -public com.google.firebase.firestore.pipeline.Field field(java.lang.String name) { throw new RuntimeException("Stub!"); } - -/** - * Creates a [Field] instance representing the field at the given path. - * - * The path can be a simple field name (e.g., "name") or a dot-separated path to a nested field - * (e.g., "address.city"). - * - * ```kotlin - * // Get the 'address.city' field - * field(FieldPath.of("address", "city")) - * ``` - * - * @param fieldPath The [FieldPath] to the field. - * @return A new [Field] instance representing the specified path. - */ - -public com.google.firebase.firestore.pipeline.Field field(com.google.firebase.firestore.FieldPath fieldPath) { throw new RuntimeException("Stub!"); } - -/** - * Creates a 'raw' function expression. This is useful if the expression is available in the - * backend, but not yet in the current version of the SDK yet. - * - * ```kotlin - * // Create a generic function call - * rawFunction("my_function", field("arg1"), constant(42)) - * ``` - * - * @param name The name of the raw function. - * @param expr The expressions to be passed as arguments to the function. - * @return A new [Expression] representing the raw function. - */ - -public com.google.firebase.firestore.pipeline.Expression rawFunction(java.lang.String name, com.google.firebase.firestore.pipeline.Expression... expr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that performs a logical 'AND' operation. - * - * ```kotlin - * // Check if 'status' is "new" and 'priority' is greater than 1 - * and(field("status").equal("new"), field("priority").greaterThan(1)) - * ``` - * - * @param condition The first [BooleanExpression]. - * @param conditions Additional [BooleanExpression]s. - * @return A new [BooleanExpression] representing the logical 'AND' operation. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression and(com.google.firebase.firestore.pipeline.BooleanExpression condition, com.google.firebase.firestore.pipeline.BooleanExpression... conditions) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that performs a logical 'OR' operation. - * - * ```kotlin - * // Check if 'status' is "new" or "open" - * or(field("status").equal("new"), field("status").equal("open")) - * ``` - * - * @param condition The first [BooleanExpression]. - * @param conditions Additional [BooleanExpression]s. - * @return A new [BooleanExpression] representing the logical 'OR' operation. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression or(com.google.firebase.firestore.pipeline.BooleanExpression condition, com.google.firebase.firestore.pipeline.BooleanExpression... conditions) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that performs a logical 'NOR' operation. - * - * ```kotlin - * // Check if 'status' is neither "new" nor "open" - * nor(field("status").equal("new"), field("status").equal("open")) - * ``` - * - * @param condition The first [BooleanExpression]. - * @param conditions Additional [BooleanExpression]s. - * @return A new [BooleanExpression] representing the logical 'NOR' operation. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression nor(com.google.firebase.firestore.pipeline.BooleanExpression condition, com.google.firebase.firestore.pipeline.BooleanExpression... conditions) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that evaluates to the result corresponding to the first true condition. - * - * This function behaves like a `switch` statement. It accepts an alternating sequence of - * conditions and their corresponding results. If an odd number of arguments is provided, the - * final argument serves as a default fallback result. If no default is provided and no - * condition evaluates to true, it throws an error. - * - * ```kotlin - * // Return "Active" if field "status" is 1, "Pending" if field "status" is 2, - * // and default to "Unknown" if none of the conditions are true. - * switchOn( - * field("status").equal(1), constant("Active"), - * field("status").equal(2), constant("Pending"), - * constant("Unknown") - * ) - * ``` - * - * @param condition The first condition to check. - * @param result The result if the first condition is true. - * @param others Additional conditions and results, and optionally a default value. - * @return A new [Expression] representing the switch operation. - */ - -public com.google.firebase.firestore.pipeline.Expression switchOn(com.google.firebase.firestore.pipeline.BooleanExpression condition, java.lang.Object result, java.lang.Object... others) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that performs a logical 'XOR' operation. - * - * ```kotlin - * // Check if either 'a' is true or 'b' is true, but not both - * xor(field("a"), field("b")) - * ``` - * - * @param condition The first [BooleanExpression]. - * @param conditions Additional [BooleanExpression]s. - * @return A new [BooleanExpression] representing the logical 'XOR' operation. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression xor(com.google.firebase.firestore.pipeline.BooleanExpression condition, com.google.firebase.firestore.pipeline.BooleanExpression... conditions) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that negates a boolean expression. - * - * ```kotlin - * // Check if 'is_admin' is not true - * not(field("is_admin")) - * ``` - * - * @param condition The boolean expression to negate. - * @return A new [BooleanExpression] representing the not operation. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression not(com.google.firebase.firestore.pipeline.BooleanExpression condition) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise AND operation between two expressions. - * - * ```kotlin - * // Bitwise AND the value of the 'flags' field with the value of the 'mask' field. - * bitAnd(field("flags"), field("mask")) - * ``` - * - * @param bits An expression that returns bits when evaluated. - * @param bitsOther An expression that returns bits when evaluated. - * @return A new [Expression] representing the bitwise AND operation. - */ - -public com.google.firebase.firestore.pipeline.Expression bitAnd(com.google.firebase.firestore.pipeline.Expression bits, com.google.firebase.firestore.pipeline.Expression bitsOther) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise AND operation between an expression and a - * constant. - * - * ```kotlin - * // Bitwise AND the value of the 'flags' field with a constant mask. - * bitAnd(field("flags"), byteArrayOf(0b00001111)) - * ``` - * - * @param bits An expression that returns bits when evaluated. - * @param bitsOther A constant byte array. - * @return A new [Expression] representing the bitwise AND operation. - */ - -public com.google.firebase.firestore.pipeline.Expression bitAnd(com.google.firebase.firestore.pipeline.Expression bits, byte[] bitsOther) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise AND operation between an field and an - * expression. - * - * ```kotlin - * // Bitwise AND the value of the 'flags' field with the value of the 'mask' field. - * bitAnd("flags", field("mask")) - * ``` - * - * @param bitsFieldName Name of field that contains bits data. - * @param bitsOther An expression that returns bits when evaluated. - * @return A new [Expression] representing the bitwise AND operation. - */ - -public com.google.firebase.firestore.pipeline.Expression bitAnd(java.lang.String bitsFieldName, com.google.firebase.firestore.pipeline.Expression bitsOther) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise AND operation between an field and constant. - * - * ```kotlin - * // Bitwise AND the value of the 'flags' field with a constant mask. - * bitAnd("flags", byteArrayOf(0b00001111)) - * ``` - * - * @param bitsFieldName Name of field that contains bits data. - * @param bitsOther A constant byte array. - * @return A new [Expression] representing the bitwise AND operation. - */ - -public com.google.firebase.firestore.pipeline.Expression bitAnd(java.lang.String bitsFieldName, byte[] bitsOther) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise OR operation between two expressions. - * - * ```kotlin - * // Bitwise OR the value of the 'flags' field with the value of the 'mask' field. - * bitOr(field("flags"), field("mask")) - * ``` - * - * @param bits An expression that returns bits when evaluated. - * @param bitsOther An expression that returns bits when evaluated. - * @return A new [Expression] representing the bitwise OR operation. - */ - -public com.google.firebase.firestore.pipeline.Expression bitOr(com.google.firebase.firestore.pipeline.Expression bits, com.google.firebase.firestore.pipeline.Expression bitsOther) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise OR operation between an expression and a - * constant. - * - * ```kotlin - * // Bitwise OR the value of the 'flags' field with a constant mask. - * bitOr(field("flags"), byteArrayOf(0b00001111)) - * ``` - * - * @param bits An expression that returns bits when evaluated. - * @param bitsOther A constant byte array. - * @return A new [Expression] representing the bitwise OR operation. - */ - -public com.google.firebase.firestore.pipeline.Expression bitOr(com.google.firebase.firestore.pipeline.Expression bits, byte[] bitsOther) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise OR operation between an field and an expression. - * - * ```kotlin - * // Bitwise OR the value of the 'flags' field with the value of the 'mask' field. - * bitOr("flags", field("mask")) - * ``` - * - * @param bitsFieldName Name of field that contains bits data. - * @param bitsOther An expression that returns bits when evaluated. - * @return A new [Expression] representing the bitwise OR operation. - */ - -public com.google.firebase.firestore.pipeline.Expression bitOr(java.lang.String bitsFieldName, com.google.firebase.firestore.pipeline.Expression bitsOther) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise OR operation between an field and constant. - * - * ```kotlin - * // Bitwise OR the value of the 'flags' field with a constant mask. - * bitOr("flags", byteArrayOf(0b00001111)) - * ``` - * - * @param bitsFieldName Name of field that contains bits data. - * @param bitsOther A constant byte array. - * @return A new [Expression] representing the bitwise OR operation. - */ - -public com.google.firebase.firestore.pipeline.Expression bitOr(java.lang.String bitsFieldName, byte[] bitsOther) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise XOR operation between two expressions. - * - * ```kotlin - * // Bitwise XOR the value of the 'flags' field with the value of the 'mask' field. - * bitXor(field("flags"), field("mask")) - * ``` - * - * @param bits An expression that returns bits when evaluated. - * @param bitsOther An expression that returns bits when evaluated. - * @return A new [Expression] representing the bitwise XOR operation. - */ - -public com.google.firebase.firestore.pipeline.Expression bitXor(com.google.firebase.firestore.pipeline.Expression bits, com.google.firebase.firestore.pipeline.Expression bitsOther) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise XOR operation between an expression and a - * constant. - * - * ```kotlin - * // Bitwise XOR the value of the 'flags' field with a constant mask. - * bitXor(field("flags"), byteArrayOf(0b00001111)) - * ``` - * - * @param bits An expression that returns bits when evaluated. - * @param bitsOther A constant byte array. - * @return A new [Expression] representing the bitwise XOR operation. - */ - -public com.google.firebase.firestore.pipeline.Expression bitXor(com.google.firebase.firestore.pipeline.Expression bits, byte[] bitsOther) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise XOR operation between an field and an - * expression. - * - * ```kotlin - * // Bitwise XOR the value of the 'flags' field with the value of the 'mask' field. - * bitXor("flags", field("mask")) - * ``` - * - * @param bitsFieldName Name of field that contains bits data. - * @param bitsOther An expression that returns bits when evaluated. - * @return A new [Expression] representing the bitwise XOR operation. - */ - -public com.google.firebase.firestore.pipeline.Expression bitXor(java.lang.String bitsFieldName, com.google.firebase.firestore.pipeline.Expression bitsOther) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise XOR operation between an field and constant. - * - * ```kotlin - * // Bitwise XOR the value of the 'flags' field with a constant mask. - * bitXor("flags", byteArrayOf(0b00001111)) - * ``` - * - * @param bitsFieldName Name of field that contains bits data. - * @param bitsOther A constant byte array. - * @return A new [Expression] representing the bitwise XOR operation. - */ - -public com.google.firebase.firestore.pipeline.Expression bitXor(java.lang.String bitsFieldName, byte[] bitsOther) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise NOT operation to an expression. - * - * ```kotlin - * // Bitwise NOT the value of the 'flags' field. - * bitNot(field("flags")) - * ``` - * - * @param bits An expression that returns bits when evaluated. - * @return A new [Expression] representing the bitwise NOT operation. - */ - -public com.google.firebase.firestore.pipeline.Expression bitNot(com.google.firebase.firestore.pipeline.Expression bits) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise NOT operation to a field. - * - * ```kotlin - * // Bitwise NOT the value of the 'flags' field. - * bitNot("flags") - * ``` - * - * @param bitsFieldName Name of field that contains bits data. - * @return A new [Expression] representing the bitwise NOT operation. - */ - -public com.google.firebase.firestore.pipeline.Expression bitNot(java.lang.String bitsFieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise left shift operation between two expressions. - * - * ```kotlin - * // Left shift the value of the 'bits' field by the value of the 'shift' field. - * bitLeftShift(field("bits"), field("shift")) - * ``` - * - * @param bits An expression that returns bits when evaluated. - * @param numberExpr The number of bits to shift. - * @return A new [Expression] representing the bitwise left shift operation. - */ - -public com.google.firebase.firestore.pipeline.Expression bitLeftShift(com.google.firebase.firestore.pipeline.Expression bits, com.google.firebase.firestore.pipeline.Expression numberExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise left shift operation between an expression and a - * constant. - * - * ```kotlin - * // Left shift the value of the 'bits' field by 2. - * bitLeftShift(field("bits"), 2) - * ``` - * - * @param bits An expression that returns bits when evaluated. - * @param number The number of bits to shift. - * @return A new [Expression] representing the bitwise left shift operation. - */ - -public com.google.firebase.firestore.pipeline.Expression bitLeftShift(com.google.firebase.firestore.pipeline.Expression bits, int number) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise left shift operation between a field and an - * expression. - * - * ```kotlin - * // Left shift the value of the 'bits' field by the value of the 'shift' field. - * bitLeftShift("bits", field("shift")) - * ``` - * - * @param bitsFieldName Name of field that contains bits data. - * @param numberExpr The number of bits to shift. - * @return A new [Expression] representing the bitwise left shift operation. - */ - -public com.google.firebase.firestore.pipeline.Expression bitLeftShift(java.lang.String bitsFieldName, com.google.firebase.firestore.pipeline.Expression numberExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise left shift operation between a field and a - * constant. - * - * ```kotlin - * // Left shift the value of the 'bits' field by 2. - * bitLeftShift("bits", 2) - * ``` - * - * @param bitsFieldName Name of field that contains bits data. - * @param number The number of bits to shift. - * @return A new [Expression] representing the bitwise left shift operation. - */ - -public com.google.firebase.firestore.pipeline.Expression bitLeftShift(java.lang.String bitsFieldName, int number) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise right shift operation between two expressions. - * - * ```kotlin - * // Right shift the value of the 'bits' field by the value of the 'shift' field. - * bitRightShift(field("bits"), field("shift")) - * ``` - * - * @param bits An expression that returns bits when evaluated. - * @param numberExpr The number of bits to shift. - * @return A new [Expression] representing the bitwise right shift operation. - */ - -public com.google.firebase.firestore.pipeline.Expression bitRightShift(com.google.firebase.firestore.pipeline.Expression bits, com.google.firebase.firestore.pipeline.Expression numberExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise right shift operation between an expression and - * a constant. - * - * ```kotlin - * // Right shift the value of the 'bits' field by 2. - * bitRightShift(field("bits"), 2) - * ``` - * - * @param bits An expression that returns bits when evaluated. - * @param number The number of bits to shift. - * @return A new [Expression] representing the bitwise right shift operation. - */ - -public com.google.firebase.firestore.pipeline.Expression bitRightShift(com.google.firebase.firestore.pipeline.Expression bits, int number) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise right shift operation between a field and an - * expression. - * - * ```kotlin - * // Right shift the value of the 'bits' field by the value of the 'shift' field. - * bitRightShift("bits", field("shift")) - * ``` - * - * @param bitsFieldName Name of field that contains bits data. - * @param numberExpr The number of bits to shift. - * @return A new [Expression] representing the bitwise right shift operation. - */ - -public com.google.firebase.firestore.pipeline.Expression bitRightShift(java.lang.String bitsFieldName, com.google.firebase.firestore.pipeline.Expression numberExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a bitwise right shift operation between a field and a - * constant. - * - * ```kotlin - * // Right shift the value of the 'bits' field by 2. - * bitRightShift("bits", 2) - * ``` - * - * @param bitsFieldName Name of field that contains bits data. - * @param number The number of bits to shift. - * @return A new [Expression] representing the bitwise right shift operation. - */ - -public com.google.firebase.firestore.pipeline.Expression bitRightShift(java.lang.String bitsFieldName, int number) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that rounds [numericExpr] to nearest integer. - * - * ```kotlin - * // Round the value of the 'price' field. - * round(field("price")) - * ``` - * - * Rounds away from zero in halfway cases. - * - * @param numericExpr An expression that returns number when evaluated. - * @return A new [Expression] representing an integer result from the round operation. - */ - -public com.google.firebase.firestore.pipeline.Expression round(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that rounds [numericField] to nearest integer. - * - * ```kotlin - * // Round the value of the 'price' field. - * round("price") - * ``` - * - * Rounds away from zero in halfway cases. - * - * @param numericField Name of field that returns number when evaluated. - * @return A new [Expression] representing an integer result from the round operation. - */ - -public com.google.firebase.firestore.pipeline.Expression round(java.lang.String numericField) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that rounds off [numericExpr] to [decimalPlace] decimal places if - * [decimalPlace] is positive, rounds off digits to the left of the decimal point if - * [decimalPlace] is negative. Rounds away from zero in halfway cases. - * - * ```kotlin - * // Round the value of the 'price' field to 2 decimal places. - * roundToPrecision(field("price"), 2) - * ``` - * - * @param numericExpr An expression that returns number when evaluated. - * @param decimalPlace The number of decimal places to round. - * @return A new [Expression] representing the round operation. - */ - -public com.google.firebase.firestore.pipeline.Expression roundToPrecision(com.google.firebase.firestore.pipeline.Expression numericExpr, int decimalPlace) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that rounds off [numericField] to [decimalPlace] decimal places if - * [decimalPlace] is positive, rounds off digits to the left of the decimal point if - * [decimalPlace] is negative. Rounds away from zero in halfway cases. - * - * ```kotlin - * // Round the value of the 'price' field to 2 decimal places. - * roundToPrecision("price", 2) - * ``` - * - * @param numericField Name of field that returns number when evaluated. - * @param decimalPlace The number of decimal places to round. - * @return A new [Expression] representing the round operation. - */ - -public com.google.firebase.firestore.pipeline.Expression roundToPrecision(java.lang.String numericField, int decimalPlace) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that rounds off [numericExpr] to [decimalPlace] decimal places if - * [decimalPlace] is positive, rounds off digits to the left of the decimal point if - * [decimalPlace] is negative. Rounds away from zero in halfway cases. - * - * ```kotlin - * // Round the value of the 'price' field to the number of decimal places specified in the - * // 'precision' field. - * roundToPrecision(field("price"), field("precision")) - * ``` - * - * @param numericExpr An expression that returns number when evaluated. - * @param decimalPlace The number of decimal places to round. - * @return A new [Expression] representing the round operation. - */ - -public com.google.firebase.firestore.pipeline.Expression roundToPrecision(com.google.firebase.firestore.pipeline.Expression numericExpr, com.google.firebase.firestore.pipeline.Expression decimalPlace) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that rounds off [numericField] to [decimalPlace] decimal places if - * [decimalPlace] is positive, rounds off digits to the left of the decimal point if - * [decimalPlace] is negative. Rounds away from zero in halfway cases. - * - * ```kotlin - * // Round the value of the 'price' field to the number of decimal places specified in the - * // 'precision' field. - * roundToPrecision("price", field("precision")) - * ``` - * - * @param numericField Name of field that returns number when evaluated. - * @param decimalPlace The number of decimal places to round. - * @return A new [Expression] representing the round operation. - */ - -public com.google.firebase.firestore.pipeline.Expression roundToPrecision(java.lang.String numericField, com.google.firebase.firestore.pipeline.Expression decimalPlace) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates [numericExpr] to an integer. - * - * ```kotlin - * // Truncate the value of the 'rating' field. - * trunc(field("rating")) - * ``` - * - * @param numericExpr An expression that returns number when evaluated. - * @return A new [Expression] representing the truncate operation. - */ - -public com.google.firebase.firestore.pipeline.Expression trunc(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates [numericField] to an integer. - * - * ```kotlin - * // Truncate the value of the 'rating' field. - * trunc("rating") - * ``` - * - * @param numericField Name of field that returns number when evaluated. - * @return A new [Expression] representing the truncate operation. - */ - -public com.google.firebase.firestore.pipeline.Expression trunc(java.lang.String numericField) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates [numericExpr] to [decimalPlace] decimal places if - * [decimalPlace] is positive, truncates digits to the left of the decimal point if - * [decimalPlace] is negative. - * - * ```kotlin - * // Truncate the value of the 'rating' field to 2 decimal places. - * truncToPrecision(field("rating"), 2) - * ``` - * - * @param numericExpr An expression that returns number when evaluated. - * @param decimalPlace The number of decimal places to truncate. - * @return A new [Expression] representing the truncate operation. - */ - -public com.google.firebase.firestore.pipeline.Expression truncToPrecision(com.google.firebase.firestore.pipeline.Expression numericExpr, int decimalPlace) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates [numericField] to [decimalPlace] decimal places if - * [decimalPlace] is positive, truncates digits to the left of the decimal point if - * [decimalPlace] is negative. - * - * ```kotlin - * // Truncate the value of the 'rating' field to 2 decimal places. - * truncToPrecision("rating", 2) - * ``` - * - * @param numericField Name of field that returns number when evaluated. - * @param decimalPlace The number of decimal places to truncate. - * @return A new [Expression] representing the truncate operation. - */ - -public com.google.firebase.firestore.pipeline.Expression truncToPrecision(java.lang.String numericField, int decimalPlace) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates [numericExpr] to [decimalPlace] decimal places if - * [decimalPlace] is positive, truncates digits to the left of the decimal point if - * [decimalPlace] is negative. - * - * ```kotlin - * // Truncate the value of the 'rating' field to the number of decimal places specified in the - * // 'precision' field. - * truncToPrecision(field("rating"), field("precision")) - * ``` - * - * @param numericExpr An expression that returns number when evaluated. - * @param decimalPlace The number of decimal places to truncate. - * @return A new [Expression] representing the truncate operation. - */ - -public com.google.firebase.firestore.pipeline.Expression truncToPrecision(com.google.firebase.firestore.pipeline.Expression numericExpr, com.google.firebase.firestore.pipeline.Expression decimalPlace) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates [numericField] to [decimalPlace] decimal places if - * [decimalPlace] is positive, truncates digits to the left of the decimal point if - * [decimalPlace] is negative. - * - * ```kotlin - * // Truncate the value of the 'rating' field to the number of decimal places specified in the - * // 'precision' field. - * truncToPrecision("rating", field("precision")) - * ``` - * - * @param numericField Name of field that returns number when evaluated. - * @param decimalPlace The number of decimal places to truncate. - * @return A new [Expression] representing the truncate operation. - */ - -public com.google.firebase.firestore.pipeline.Expression truncToPrecision(java.lang.String numericField, com.google.firebase.firestore.pipeline.Expression decimalPlace) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the smallest integer that isn't less than [numericExpr]. - * - * ```kotlin - * // Compute the ceiling of the 'price' field. - * ceil(field("price")) - * ``` - * - * @param numericExpr An expression that returns number when evaluated. - * @return A new [Expression] representing an integer result from the ceil operation. - */ - -public com.google.firebase.firestore.pipeline.Expression ceil(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the smallest integer that isn't less than [numericField]. - * - * ```kotlin - * // Compute the ceiling of the 'price' field. - * ceil("price") - * ``` - * - * @param numericField Name of field that returns number when evaluated. - * @return A new [Expression] representing an integer result from the ceil operation. - */ - -public com.google.firebase.firestore.pipeline.Expression ceil(java.lang.String numericField) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the largest integer that is not greater than [numericExpr] - * - * ```kotlin - * // Compute the floor of the 'price' field. - * floor(field("price")) - * ``` - * - * @param numericExpr An expression that returns number when evaluated. - * @return A new [Expression] representing an integer result from the floor operation. - */ - -public com.google.firebase.firestore.pipeline.Expression floor(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the largest integer that is not greater than - * [numericField]. - * - * ```kotlin - * // Compute the floor of the 'price' field. - * floor("price") - * ``` - * - * @param numericField Name of field that returns number when evaluated. - * @return A new [Expression] representing an integer result from the floor operation. - */ - -public com.google.firebase.firestore.pipeline.Expression floor(java.lang.String numericField) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [numericExpr] raised to the power of the [exponent]. - * Returns infinity on overflow and zero on underflow. - * - * ```kotlin - * // Raise the value of the 'base' field to the power of 2. - * pow(field("base"), 2) - * ``` - * - * @param numericExpr An expression that returns number when evaluated. - * @param exponent The numeric power to raise the [numericExpr]. - * @return A new [Expression] representing a numeric result from raising [numericExpr] to the - * power of [exponent]. - */ - -public com.google.firebase.firestore.pipeline.Expression pow(com.google.firebase.firestore.pipeline.Expression numericExpr, java.lang.Number exponent) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [numericField] raised to the power of the [exponent]. - * Returns infinity on overflow and zero on underflow. - * - * ```kotlin - * // Raise the value of the 'base' field to the power of 2. - * pow("base", 2) - * ``` - * - * @param numericField Name of field that returns number when evaluated. - * @param exponent The numeric power to raise the [numericField]. - * @return A new [Expression] representing a numeric result from raising [numericField] to the - * power of [exponent]. - */ - -public com.google.firebase.firestore.pipeline.Expression pow(java.lang.String numericField, java.lang.Number exponent) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [numericExpr] raised to the power of the [exponent]. - * Returns infinity on overflow and zero on underflow. - * - * ```kotlin - * // Raise the value of the 'base' field to the power of the 'exponent' field. - * pow(field("base"), field("exponent")) - * ``` - * - * @param numericExpr An expression that returns number when evaluated. - * @param exponent The numeric power to raise the [numericExpr]. - * @return A new [Expression] representing a numeric result from raising [numericExpr] to the - * power of [exponent]. - */ - -public com.google.firebase.firestore.pipeline.Expression pow(com.google.firebase.firestore.pipeline.Expression numericExpr, com.google.firebase.firestore.pipeline.Expression exponent) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [numericField] raised to the power of the [exponent]. - * Returns infinity on overflow and zero on underflow. - * - * ```kotlin - * // Raise the value of the 'base' field to the power of the 'exponent' field. - * pow("base", field("exponent")) - * ``` - * - * @param numericField Name of field that returns number when evaluated. - * @param exponent The numeric power to raise the [numericField]. - * @return A new [Expression] representing a numeric result from raising [numericField] to the - * power of [exponent]. - */ - -public com.google.firebase.firestore.pipeline.Expression pow(java.lang.String numericField, com.google.firebase.firestore.pipeline.Expression exponent) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the absolute value of [numericExpr]. - * - * ```kotlin - * // Get the absolute value of the 'change' field. - * abs(field("change")) - * ``` - * - * @param numericExpr An expression that returns number when evaluated. - * @return A new [Expression] representing the numeric result of the absolute value operation. - */ - -public com.google.firebase.firestore.pipeline.Expression abs(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the absolute value of [numericField]. - * - * ```kotlin - * // Get the absolute value of the 'change' field. - * abs("change") - * ``` - * - * @param numericField Name of field that returns number when evaluated. - * @return A new [Expression] representing the numeric result of the absolute value operation. - */ - -public com.google.firebase.firestore.pipeline.Expression abs(java.lang.String numericField) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns Euler's number e raised to the power of [numericExpr]. - * - * ```kotlin - * // Compute e to the power of the 'value' field. - * exp(field("value")) - * ``` - * - * @param numericExpr An expression that returns number when evaluated. - * @return A new [Expression] representing the numeric result of the exponentiation. - */ - -public com.google.firebase.firestore.pipeline.Expression exp(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns Euler's number e raised to the power of [numericField]. - * - * ```kotlin - * // Compute e to the power of the 'value' field. - * exp("value") - * ``` - * - * @param numericField Name of field that returns number when evaluated. - * @return A new [Expression] representing the numeric result of the exponentiation. - */ - -public com.google.firebase.firestore.pipeline.Expression exp(java.lang.String numericField) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the natural logarithm (base e) of [numericExpr]. - * - * ```kotlin - * // Compute the natural logarithm of the 'value' field. - * ln(field("value")) - * ``` - * - * @param numericExpr An expression that returns number when evaluated. - * @return A new [Expression] representing the numeric result of the natural logarithm. - */ - -public com.google.firebase.firestore.pipeline.Expression ln(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the natural logarithm (base e) of [numericField]. - * - * ```kotlin - * // Compute the natural logarithm of the 'value' field. - * ln("value") - * ``` - * - * @param numericField Name of field that returns number when evaluated. - * @return A new [Expression] representing the numeric result of the natural logarithm. - */ - -public com.google.firebase.firestore.pipeline.Expression ln(java.lang.String numericField) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the logarithm of [numericExpr] with a given [base]. - * - * ```kotlin - * // Compute the logarithm of the 'value' field with base 10. - * log(field("value"), 10) - * ``` - * - * @param numericExpr An expression that returns number when evaluated. - * @param base The base of the logarithm. - * @return A new [Expression] representing a numeric result from the logarithm of [numericExpr] - * with a given [base]. - */ - -public com.google.firebase.firestore.pipeline.Expression log(com.google.firebase.firestore.pipeline.Expression numericExpr, java.lang.Number base) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the logarithm of [numericField] with a given [base]. - * - * ```kotlin - * // Compute the logarithm of the 'value' field with base 10. - * log("value", 10) - * ``` - * - * @param numericField Name of field that returns number when evaluated. - * @param base The base of the logarithm. - * @return A new [Expression] representing a numeric result from the logarithm of [numericField] - * with a given [base]. - */ - -public com.google.firebase.firestore.pipeline.Expression log(java.lang.String numericField, java.lang.Number base) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the logarithm of [numericExpr] with a given [base]. - * - * ```kotlin - * // Compute the logarithm of the 'value' field with the base in the 'base' field. - * log(field("value"), field("base")) - * ``` - * - * @param numericExpr An expression that returns number when evaluated. - * @param base The base of the logarithm. - * @return A new [Expression] representing a numeric result from the logarithm of [numericExpr] - * with a given [base]. - */ - -public com.google.firebase.firestore.pipeline.Expression log(com.google.firebase.firestore.pipeline.Expression numericExpr, com.google.firebase.firestore.pipeline.Expression base) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the logarithm of [numericField] with a given [base]. - * - * ```kotlin - * // Compute the logarithm of the 'value' field with the base in the 'base' field. - * log("value", field("base")) - * ``` - * - * @param numericField Name of field that returns number when evaluated. - * @param base The base of the logarithm. - * @return A new [Expression] representing a numeric result from the logarithm of [numericField] - * with a given [base]. - */ - -public com.google.firebase.firestore.pipeline.Expression log(java.lang.String numericField, com.google.firebase.firestore.pipeline.Expression base) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the base 10 logarithm of [numericExpr]. - * - * ```kotlin - * // Compute the base 10 logarithm of the 'value' field. - * log10(field("value")) - * ``` - * - * @param numericExpr An expression that returns number when evaluated. - * @return A new [Expression] representing the numeric result of the base 10 logarithm. - */ - -public com.google.firebase.firestore.pipeline.Expression log10(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the base 10 logarithm of [numericField]. - * - * ```kotlin - * // Compute the base 10 logarithm of the 'value' field. - * log10("value") - * ``` - * - * @param numericField Name of field that returns number when evaluated. - * @return A new [Expression] representing the numeric result of the base 10 logarithm. - */ - -public com.google.firebase.firestore.pipeline.Expression log10(java.lang.String numericField) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the square root of [numericExpr]. - * - * ```kotlin - * // Compute the square root of the 'value' field. - * sqrt(field("value")) - * ``` - * - * @param numericExpr An expression that returns number when evaluated. - * @return A new [Expression] representing the numeric result of the square root operation. - */ - -public com.google.firebase.firestore.pipeline.Expression sqrt(com.google.firebase.firestore.pipeline.Expression numericExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the square root of [numericField]. - * - * ```kotlin - * // Compute the square root of the 'value' field. - * sqrt("value") - * ``` - * - * @param numericField Name of field that returns number when evaluated. - * @return A new [Expression] representing the numeric result of the square root operation. - */ - -public com.google.firebase.firestore.pipeline.Expression sqrt(java.lang.String numericField) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that adds numeric expressions. - * - * ```kotlin - * // Add the value of the 'quantity' field and the 'reserve' field. - * add(field("quantity"), field("reserve")) - * ``` - * - * @param first Numeric expression to add. - * @param second Numeric expression to add. - * @return A new [Expression] representing the addition operation. - */ - -public com.google.firebase.firestore.pipeline.Expression add(com.google.firebase.firestore.pipeline.Expression first, com.google.firebase.firestore.pipeline.Expression second) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that adds numeric expressions with a constant. - * - * ```kotlin - * // Add 5 to the value of the 'quantity' field. - * add(field("quantity"), 5) - * ``` - * - * @param first Numeric expression to add. - * @param second Constant to add. - * @return A new [Expression] representing the addition operation. - */ - -public com.google.firebase.firestore.pipeline.Expression add(com.google.firebase.firestore.pipeline.Expression first, java.lang.Number second) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that adds a numeric field with a numeric expression. - * - * ```kotlin - * // Add the value of the 'quantity' field and the 'reserve' field. - * add("quantity", field("reserve")) - * ``` - * - * @param numericFieldName Numeric field to add. - * @param second Numeric expression to add to field value. - * @return A new [Expression] representing the addition operation. - */ - -public com.google.firebase.firestore.pipeline.Expression add(java.lang.String numericFieldName, com.google.firebase.firestore.pipeline.Expression second) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that adds a numeric field with constant. - * - * ```kotlin - * // Add 5 to the value of the 'quantity' field. - * add("quantity", 5) - * ``` - * - * @param numericFieldName Numeric field to add. - * @param second Constant to add. - * @return A new [Expression] representing the addition operation. - */ - -public com.google.firebase.firestore.pipeline.Expression add(java.lang.String numericFieldName, java.lang.Number second) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that subtracts two expressions. - * - * ```kotlin - * // Subtract the 'discount' field from the 'price' field - * subtract(field("price"), field("discount")) - * ``` - * - * @param minuend Numeric expression to subtract from. - * @param subtrahend Numeric expression to subtract. - * @return A new [Expression] representing the subtract operation. - */ - -public com.google.firebase.firestore.pipeline.Expression subtract(com.google.firebase.firestore.pipeline.Expression minuend, com.google.firebase.firestore.pipeline.Expression subtrahend) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that subtracts a constant value from a numeric expression. - * - * ```kotlin - * // Subtract 10 from the 'price' field. - * subtract(field("price"), 10) - * ``` - * - * @param minuend Numeric expression to subtract from. - * @param subtrahend Constant to subtract. - * @return A new [Expression] representing the subtract operation. - */ - -public com.google.firebase.firestore.pipeline.Expression subtract(com.google.firebase.firestore.pipeline.Expression minuend, java.lang.Number subtrahend) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that subtracts a numeric expressions from numeric field. - * - * ```kotlin - * // Subtract the 'discount' field from the 'price' field. - * subtract("price", field("discount")) - * ``` - * - * @param numericFieldName Numeric field to subtract from. - * @param subtrahend Numeric expression to subtract. - * @return A new [Expression] representing the subtract operation. - */ - -public com.google.firebase.firestore.pipeline.Expression subtract(java.lang.String numericFieldName, com.google.firebase.firestore.pipeline.Expression subtrahend) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that subtracts a constant from numeric field. - * - * ```kotlin - * // Subtract 10 from the 'price' field. - * subtract("price", 10) - * ``` - * - * @param numericFieldName Numeric field to subtract from. - * @param subtrahend Constant to subtract. - * @return A new [Expression] representing the subtract operation. - */ - -public com.google.firebase.firestore.pipeline.Expression subtract(java.lang.String numericFieldName, java.lang.Number subtrahend) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that multiplies numeric expressions. - * - * ```kotlin - * // Multiply the 'quantity' field by the 'price' field - * multiply(field("quantity"), field("price")) - * ``` - * - * @param first Numeric expression to multiply. - * @param second Numeric expression to multiply. - * @return A new [Expression] representing the multiplication operation. - */ - -public com.google.firebase.firestore.pipeline.Expression multiply(com.google.firebase.firestore.pipeline.Expression first, com.google.firebase.firestore.pipeline.Expression second) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that multiplies numeric expressions with a constant. - * - * ```kotlin - * // Multiply the 'quantity' field by 1.1. - * multiply(field("quantity"), 1.1) - * ``` - * - * @param first Numeric expression to multiply. - * @param second Constant to multiply. - * @return A new [Expression] representing the multiplication operation. - */ - -public com.google.firebase.firestore.pipeline.Expression multiply(com.google.firebase.firestore.pipeline.Expression first, java.lang.Number second) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that multiplies a numeric field with a numeric expression. - * - * ```kotlin - * // Multiply the 'quantity' field by the 'price' field. - * multiply("quantity", field("price")) - * ``` - * - * @param numericFieldName Numeric field to multiply. - * @param second Numeric expression to multiply. - * @return A new [Expression] representing the multiplication operation. - */ - -public com.google.firebase.firestore.pipeline.Expression multiply(java.lang.String numericFieldName, com.google.firebase.firestore.pipeline.Expression second) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that multiplies a numeric field with a constant. - * - * ```kotlin - * // Multiply the 'quantity' field by 1.1. - * multiply("quantity", 1.1) - * ``` - * - * @param numericFieldName Numeric field to multiply. - * @param second Constant to multiply. - * @return A new [Expression] representing the multiplication operation. - */ - -public com.google.firebase.firestore.pipeline.Expression multiply(java.lang.String numericFieldName, java.lang.Number second) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that divides two numeric expressions. - * - * ```kotlin - * // Divide the 'total' field by the 'count' field - * divide(field("total"), field("count")) - * ``` - * - * @param dividend The numeric expression to be divided. - * @param divisor The numeric expression to divide by. - * @return A new [Expression] representing the division operation. - */ - -public com.google.firebase.firestore.pipeline.Expression divide(com.google.firebase.firestore.pipeline.Expression dividend, com.google.firebase.firestore.pipeline.Expression divisor) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that divides a numeric expression by a constant. - * - * ```kotlin - * // Divide the 'value' field by 10 - * divide(field("value"), 10) - * ``` - * - * @param dividend The numeric expression to be divided. - * @param divisor The constant to divide by. - * @return A new [Expression] representing the division operation. - */ - -public com.google.firebase.firestore.pipeline.Expression divide(com.google.firebase.firestore.pipeline.Expression dividend, java.lang.Number divisor) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that divides numeric field by a numeric expression. - * - * ```kotlin - * // Divide the 'total' field by the 'count' field. - * divide("total", field("count")) - * ``` - * - * @param dividendFieldName The numeric field name to be divided. - * @param divisor The numeric expression to divide by. - * @return A new [Expression] representing the divide operation. - */ - -public com.google.firebase.firestore.pipeline.Expression divide(java.lang.String dividendFieldName, com.google.firebase.firestore.pipeline.Expression divisor) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that divides a numeric field by a constant. - * - * ```kotlin - * // Divide the 'total' field by 2. - * divide("total", 2) - * ``` - * - * @param dividendFieldName The numeric field name to be divided. - * @param divisor The constant to divide by. - * @return A new [Expression] representing the divide operation. - */ - -public com.google.firebase.firestore.pipeline.Expression divide(java.lang.String dividendFieldName, java.lang.Number divisor) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the modulo (remainder) of dividing two numeric - * expressions. - * - * ```kotlin - * // Calculate the remainder of dividing the 'value' field by the 'divisor' field - * mod(field("value"), field("divisor")) - * ``` - * - * @param dividend The numeric expression to be divided. - * @param divisor The numeric expression to divide by. - * @return A new [Expression] representing the modulo operation. - */ - -public com.google.firebase.firestore.pipeline.Expression mod(com.google.firebase.firestore.pipeline.Expression dividend, com.google.firebase.firestore.pipeline.Expression divisor) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the modulo (remainder) of dividing a numeric expression - * by a constant. - * - * ```kotlin - * // Calculate the remainder of dividing the 'value' field by 3. - * mod(field("value"), 3) - * ``` - * - * @param dividend The numeric expression to be divided. - * @param divisor The constant to divide by. - * @return A new [Expression] representing the modulo operation. - */ - -public com.google.firebase.firestore.pipeline.Expression mod(com.google.firebase.firestore.pipeline.Expression dividend, java.lang.Number divisor) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the modulo (remainder) of dividing a numeric field by a - * constant. - * - * ```kotlin - * // Calculate the remainder of dividing the 'value' field by the 'divisor' field. - * mod("value", field("divisor")) - * ``` - * - * @param dividendFieldName The numeric field name to be divided. - * @param divisor The numeric expression to divide by. - * @return A new [Expression] representing the modulo operation. - */ - -public com.google.firebase.firestore.pipeline.Expression mod(java.lang.String dividendFieldName, com.google.firebase.firestore.pipeline.Expression divisor) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the modulo (remainder) of dividing a numeric field by a - * constant. - * - * ```kotlin - * // Calculate the remainder of dividing the 'value' field by 3. - * mod("value", 3) - * ``` - * - * @param dividendFieldName The numeric field name to be divided. - * @param divisor The constant to divide by. - * @return A new [Expression] representing the modulo operation. - */ - -public com.google.firebase.firestore.pipeline.Expression mod(java.lang.String dividendFieldName, java.lang.Number divisor) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if an [expression], when evaluated, is equal to any of the - * provided [values]. - * - * ```kotlin - * // Check if the 'category' field is either "Electronics" or the value of the 'primaryType' field. - * equalAny(field("category"), listOf("Electronics", field("primaryType"))) - * ``` - * - * @param expression The expression whose results to compare. - * @param values The values to check against. - * @return A new [BooleanExpression] representing the 'IN' comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression equalAny(com.google.firebase.firestore.pipeline.Expression expression, java.util.List values) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if an [expression], when evaluated, is equal to any of the - * elements of [arrayExpression]. - * - * ```kotlin - * // Check if the 'category' field is in the 'availableCategories' array field. - * equalAny(field("category"), field("availableCategories")) - * ``` - * - * @param expression The expression whose results to compare. - * @param arrayExpression An expression that evaluates to an array, whose elements to check for - * equality to the input. - * @return A new [BooleanExpression] representing the 'IN' comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression equalAny(com.google.firebase.firestore.pipeline.Expression expression, com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field's value is equal to any of the provided [values] - * . - * - * ```kotlin - * // Check if the 'category' field is either "Electronics" or "Apparel". - * equalAny("category", listOf("Electronics", "Apparel")) - * ``` - * - * @param fieldName The field to compare. - * @param values The values to check against. - * @return A new [BooleanExpression] representing the 'IN' comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression equalAny(java.lang.String fieldName, java.util.List values) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field's value is equal to any of the elements of - * [arrayExpression]. - * - * ```kotlin - * // Check if the 'category' field is in the 'availableCategories' array field. - * equalAny("category", field("availableCategories")) - * ``` - * - * @param fieldName The field to compare. - * @param arrayExpression An expression that evaluates to an array, whose elements to check for - * equality to the input. - * @return A new [BooleanExpression] representing the 'IN' comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression equalAny(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if an [expression], when evaluated, is not equal to all the - * provided [values]. - * - * ```kotlin - * // Check if the 'status' field is neither "pending" nor the value of the 'rejectedStatus' field. - * notEqualAny(field("status"), listOf("pending", field("rejectedStatus"))) - * ``` - * - * @param expression The expression whose results to compare. - * @param values The values to check against. - * @return A new [BooleanExpression] representing the 'NOT IN' comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression notEqualAny(com.google.firebase.firestore.pipeline.Expression expression, java.util.List values) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if an [expression], when evaluated, is not equal to all the - * elements of [arrayExpression]. - * - * ```kotlin - * // Check if the 'status' field is not in the 'inactiveStatuses' array field. - * notEqualAny(field("status"), field("inactiveStatuses")) - * ``` - * - * @param expression The expression whose results to compare. - * @param arrayExpression An expression that evaluates to an array, whose elements to check for - * equality to the input. - * @return A new [BooleanExpression] representing the 'NOT IN' comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression notEqualAny(com.google.firebase.firestore.pipeline.Expression expression, com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field's value is not equal to all of the provided - * [values]. - * - * ```kotlin - * // Check if the 'status' field is not "archived" or "deleted". - * notEqualAny("status", listOf("archived", "deleted")) - * ``` - * - * @param fieldName The field to compare. - * @param values The values to check against. - * @return A new [BooleanExpression] representing the 'NOT IN' comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression notEqualAny(java.lang.String fieldName, java.util.List values) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field's value is not equal to all of the elements of - * [arrayExpression]. - * - * ```kotlin - * // Check if the 'status' field is not in the 'inactiveStatuses' array field. - * notEqualAny("status", field("inactiveStatuses")) - * ``` - * - * @param fieldName The field to compare. - * @param arrayExpression An expression that evaluates to an array, whose elements to check for - * equality to the input. - * @return A new [BooleanExpression] representing the 'NOT IN' comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression notEqualAny(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns true if a value is absent. Otherwise, returns false even - * if the value is null. - * - * ```kotlin - * // Check if the field `value` is absent. - * isAbsent(field("value")) - * ``` - * - * @param value The expression to check. - * @return A new [BooleanExpression] representing the isAbsent operation. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression isAbsent(com.google.firebase.firestore.pipeline.Expression value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns true if a field is absent. Otherwise, returns false even - * if the field value is null. - * - * ```kotlin - * // Check if the field `value` is absent. - * isAbsent("value") - * ``` - * - * @param fieldName The field to check. - * @return A new [BooleanExpression] representing the isAbsent operation. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression isAbsent(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a string indicating the type of the value this expression - * evaluates to. - * - * ```kotlin - * // Get the type of the 'value' field. - * type(field("value")) - * ``` - * - * @param expr The expression to get the type of. - * @return A new [Expression] representing the type operation. - */ - -public com.google.firebase.firestore.pipeline.Expression type(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a string indicating the type of the value this field - * evaluates to. - * - * ```kotlin - * // Get the type of the 'field' field. - * type("field") - * ``` - * - * @param fieldName The name of the field to get the type of. - * @return A new [Expression] representing the type operation. - */ - -public com.google.firebase.firestore.pipeline.Expression type(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if the result of an expression is of the given type. - * - * Supported values for `type` are: "null", "array", "boolean", "bytes", "timestamp", - * "geo_point", "number", "int32", "int64", "float64", "decimal128", "map", "reference", - * "string", "vector", "max_key", "min_key", "object_id", "regex", and "request_timestamp". - * - * ```kotlin - * // Check if the 'age' field is an integer - * isType(field("age"), "int64") - * ``` - * - * @param expr The expression to check the type of. - * @param type The type to check for. - * @return A new [BooleanExpression] that evaluates to true if the expression's result is of the - * given type, false otherwise. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression isType(com.google.firebase.firestore.pipeline.Expression expr, java.lang.String type) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if the value of a field is of the given type. - * - * Supported values for `type` are: "null", "array", "boolean", "bytes", "timestamp", - * "geo_point", "number", "int32", "int64", "float64", "decimal128", "map", "reference", - * "string", "vector", "max_key", "min_key", "object_id", "regex", and "request_timestamp". - * - * ```kotlin - * // Check if the 'age' field is an integer - * isType("age", "int64") - * ``` - * - * @param fieldName The name of the field to check the type of. - * @param type The type to check for. - * @return A new [BooleanExpression] that evaluates to true if the expression's result is of the - * given type, false otherwise. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression isType(java.lang.String fieldName, java.lang.String type) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the length of a string, array, map, vector, or blob - * expression. - * - * ```kotlin - * // Get the length of the 'value' field where the value type can be any of a string, array, map, vector or blob. - * length(field("value")) - * ``` - * - * @param expr The expression representing the string. - * @return A new [Expression] representing the length operation. - */ - -public com.google.firebase.firestore.pipeline.Expression length(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the length of a string, array, map, vector, or blob - * field. - * - * ```kotlin - * // Get the length of the 'value' field where the value type can be any of a string, array, map, vector or blob. - * charLength("value") - * ``` - * - * @param fieldName The name of the field containing the string. - * @return A new [Expression] representing the length operation. - */ - -public com.google.firebase.firestore.pipeline.Expression length(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the character length of a string expression in UTF8. - * - * ```kotlin - * // Get the character length of the 'name' field in UTF-8. - * charLength("name") - * ``` - * - * @param expr The expression representing the string. - * @return A new [Expression] representing the charLength operation. - */ - -public com.google.firebase.firestore.pipeline.Expression charLength(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the character length of a string field in UTF8. - * - * ```kotlin - * // Get the character length of the 'name' field in UTF-8. - * charLength("name") - * ``` - * - * @param fieldName The name of the field containing the string. - * @return A new [Expression] representing the charLength operation. - */ - -public com.google.firebase.firestore.pipeline.Expression charLength(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the length of a string in UTF-8 bytes, or just the - * length of a Blob. - * - * ```kotlin - * // Calculate the length of the 'myString' field in bytes. - * byteLength("myString") - * ``` - * - * @param value The expression representing the string. - * @return A new [Expression] representing the length of the string in bytes. - */ - -public com.google.firebase.firestore.pipeline.Expression byteLength(com.google.firebase.firestore.pipeline.Expression value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the length of a string represented by a field in UTF-8 - * bytes, or just the length of a Blob. - * - * ```kotlin - * // Calculate the length of the 'myString' field in bytes. - * byteLength("myString") - * ``` - * - * @param fieldName The name of the field containing the string. - * @return A new [Expression] representing the length of the string in bytes. - */ - -public com.google.firebase.firestore.pipeline.Expression byteLength(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that performs a case-sensitive wildcard string comparison. - * - * ```kotlin - * // Check if the 'title' field contains the string "guide" - * like(field("title"), "%guide%") - * ``` - * - * @param stringExpression The expression representing the string to perform the comparison on. - * @param pattern The pattern to search for. You can use "%" as a wildcard character. - * @return A new [BooleanExpression] representing the like operation. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression like(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that splits a string or blob by a delimiter. - * - * ```kotlin - * // Split the 'tags' field by a comma - * split(field("tags"), field("delimiter")) - * ``` - * - * @param value The expression evaluating to a string or blob to be split. - * @param delimiter The delimiter to split by. Must be of the same type as `value`. - * @return A new [Expression] that evaluates to an array of segments. - */ - -public com.google.firebase.firestore.pipeline.Expression split(com.google.firebase.firestore.pipeline.Expression value, com.google.firebase.firestore.pipeline.Expression delimiter) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that splits a string or blob by a string delimiter. - * - * ```kotlin - * // Split the 'tags' field by a comma - * split(field("tags"), ",") - * ``` - * - * @param value The expression evaluating to a string or blob to be split. - * @param delimiter The string delimiter to split by. - * @return A new [Expression] that evaluates to an array of segments. - */ - -public com.google.firebase.firestore.pipeline.Expression split(com.google.firebase.firestore.pipeline.Expression value, java.lang.String delimiter) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that splits a blob by a blob delimiter. - * - * ```kotlin - * // Split the 'data' field by a delimiter - * split(field("data"), Blob.fromBytes(byteArrayOf(0x0a))) - * ``` - * - * @param value The expression evaluating to a blob to be split. - * @param delimiter The blob delimiter to split by. - * @return A new [Expression] that evaluates to an array of segments. - */ - -public com.google.firebase.firestore.pipeline.Expression split(com.google.firebase.firestore.pipeline.Expression value, com.google.firebase.firestore.Blob delimiter) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that splits a string or blob field by a delimiter. - * - * ```kotlin - * // Split the 'tags' field by the value of the 'delimiter' field - * split("tags", field("delimiter")) - * ``` - * - * @param fieldName The name of the field containing the string or blob to be split. - * @param delimiter The delimiter to split by. - * @return A new [Expression] that evaluates to an array of segments. - */ - -public com.google.firebase.firestore.pipeline.Expression split(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression delimiter) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that splits a string or blob field by a string delimiter. - * - * ```kotlin - * // Split the 'tags' field by a comma - * split("tags", ",") - * ``` - * - * @param fieldName The name of the field containing the string or blob to be split. - * @param delimiter The string delimiter to split by. - * @return A new [Expression] that evaluates to an array of segments. - */ - -public com.google.firebase.firestore.pipeline.Expression split(java.lang.String fieldName, java.lang.String delimiter) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that splits a blob field by a blob delimiter. - * - * ```kotlin - * // Split the 'data' field by a delimiter - * split("data", Blob.fromBytes(byteArrayOf(0x0a))) - * ``` - * - * @param fieldName The name of the field containing the blob to be split. - * @param delimiter The blob delimiter to split by. - * @return A new [Expression] that evaluates to an array of segments. - */ - -public com.google.firebase.firestore.pipeline.Expression split(java.lang.String fieldName, com.google.firebase.firestore.Blob delimiter) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that joins the elements of an array into a string. - * - * ```kotlin - * // Join the elements of the 'tags' field with a comma and space. - * join(field("tags"), ", ") - * ``` - * - * @param arrayExpression The expression that evaluates to an array. - * @param delimiter The string to use as a delimiter. - * @return A new [Expression] representing the join operation. - */ - -public com.google.firebase.firestore.pipeline.Expression join(com.google.firebase.firestore.pipeline.Expression arrayExpression, java.lang.String delimiter) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that joins the elements of an array into a string. - * - * ```kotlin - * // Join the elements of the 'tags' field with the delimiter from the 'separator' field. - * join(field("tags"), field("separator")) - * ``` - * - * @param arrayExpression The expression that evaluates to an array. - * @param delimiterExpression The expression that evaluates to the delimiter string. - * @return A new [Expression] representing the join operation. - */ - -public com.google.firebase.firestore.pipeline.Expression join(com.google.firebase.firestore.pipeline.Expression arrayExpression, com.google.firebase.firestore.pipeline.Expression delimiterExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that joins the elements of an array field into a string. - * - * ```kotlin - * // Join the elements of the 'tags' field with a comma and space. - * join("tags", ", ") - * ``` - * - * @param arrayFieldName The name of the field containing the array. - * @param delimiter The string to use as a delimiter. - * @return A new [Expression] representing the join operation. - */ - -public com.google.firebase.firestore.pipeline.Expression join(java.lang.String arrayFieldName, java.lang.String delimiter) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that joins the elements of an array field into a string. - * - * ```kotlin - * // Join the elements of the 'tags' field with the delimiter from the 'separator' field. - * join("tags", field("separator")) - * ``` - * - * @param arrayFieldName The name of the field containing the array. - * @param delimiterExpression The expression that evaluates to the delimiter string. - * @return A new [Expression] representing the join operation. - */ - -public com.google.firebase.firestore.pipeline.Expression join(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression delimiterExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that performs a case-sensitive wildcard string comparison. - * - * ```kotlin - * // Check if the 'title' field contains the string "guide" - * like(field("title"), "%guide%") - * ``` - * - * @param stringExpression The expression representing the string to perform the comparison on. - * @param pattern The pattern to search for. You can use "%" as a wildcard character. - * @return A new [BooleanExpression] representing the like operation. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression like(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that performs a case-sensitive wildcard string comparison against a - * field. - * - * ```kotlin - * // Check if the 'title' field contains the string "guide" - * like("title", "%guide%") - * ``` - * - * @param fieldName The name of the field containing the string. - * @param pattern The pattern to search for. You can use "%" as a wildcard character. - * @return A new [BooleanExpression] representing the like comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression like(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that performs a case-sensitive wildcard string comparison against a - * field. - * - * ```kotlin - * // Check if the 'title' field contains the string "guide" - * like("title", "%guide%") - * ``` - * - * @param fieldName The name of the field containing the string. - * @param pattern The pattern to search for. You can use "%" as a wildcard character. - * @return A new [BooleanExpression] representing the like comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression like(java.lang.String fieldName, java.lang.String pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a pseudo-random number of type double in the range of [0, - * 1), inclusive of 0 and exclusive of 1. - * - * ```kotlin - * // Get a random number. - * rand() - * ``` - * - * @return A new [Expression] representing the random number operation. - */ - -public com.google.firebase.firestore.pipeline.Expression rand() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string expression contains a specified regular - * expression as a substring. - * - * ```kotlin - * // Check if the 'description' field contains "example" (case-insensitive) - * regexContains(field("description"), "(?i)example") - * ``` - * - * @param stringExpression The expression representing the string to perform the comparison on. - * @param pattern The regular expression to use for the search. - * @return A new [BooleanExpression] representing the contains regular expression comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression regexContains(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string expression contains a specified regular - * expression as a substring. - * - * ```kotlin - * // Check if the 'description' field contains "example" (case-insensitive) - * regexContains(field("description"), "(?i)example") - * ``` - * - * @param stringExpression The expression representing the string to perform the comparison on. - * @param pattern The regular expression to use for the search. - * @return A new [BooleanExpression] representing the contains regular expression comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression regexContains(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string field contains a specified regular expression - * as a substring. - * - * ```kotlin - * // Check if the 'description' field contains the regex from the 'pattern' field. - * regexContains("description", field("pattern")) - * ``` - * - * @param fieldName The name of the field containing the string. - * @param pattern The regular expression to use for the search. - * @return A new [BooleanExpression] representing the contains regular expression comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression regexContains(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string field contains a specified regular expression - * as a substring. - * - * ```kotlin - * // Check if the 'description' field contains "example" (case-insensitive) - * regexContains("description", "(?i)example") - * ``` - * - * @param fieldName The name of the field containing the string. - * @param pattern The regular expression to use for the search. - * @return A new [BooleanExpression] representing the contains regular expression comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression regexContains(java.lang.String fieldName, java.lang.String pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first substring of a string expression that matches a - * specified regular expression. - * - * This expression uses the [RE2](https://github.com/google/re2/wiki/Syntax) regular expression - * syntax. - * - * ```kotlin - * // Extract a substring based on a dynamic pattern field - * regexFind(field("email"), field("pattern")) - * ``` - * - * @param stringExpression The expression representing the string to search. - * @param pattern The regular expression to search for. - * @return A new [Expression] representing the regular expression find function. - */ - -public com.google.firebase.firestore.pipeline.Expression regexFind(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first substring of a string expression that matches a - * specified regular expression. - * - * This expression uses the [RE2](https://github.com/google/re2/wiki/Syntax) regular expression - * syntax. - * - * ```kotlin - * // Extract the domain from a lower-cased email address - * regexFind(field("email"), "@[A-Za-z0-9.-]+") - * ``` - * - * @param stringExpression The expression representing the string to search. - * @param pattern The regular expression to search for. - * @return A new [Expression] representing the regular expression find function. - */ - -public com.google.firebase.firestore.pipeline.Expression regexFind(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first substring of a string field that matches a - * specified regular expression. - * - * This expression uses the [RE2](https://github.com/google/re2/wiki/Syntax) regular expression - * syntax. - * - * ```kotlin - * // Extract a substring from 'email' based on a pattern stored in another field - * regexFind("email", field("pattern")) - * ``` - * - * @param fieldName The name of the field containing the string to search. - * @param pattern The regular expression to search for. - * @return A new [Expression] representing the regular expression find function. - */ - -public com.google.firebase.firestore.pipeline.Expression regexFind(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first substring of a string field that matches a - * specified regular expression. - * - * This expression uses the [RE2](https://github.com/google/re2/wiki/Syntax) regular expression - * syntax. - * - * ```kotlin - * // Extract the domain name from an email field - * regexFind("email", "@[A-Za-z0-9.-]+") - * ``` - * - * @param fieldName The name of the field containing the string to search. - * @param pattern The regular expression to search for. - * @return A new [Expression] representing the regular expression find function. - */ - -public com.google.firebase.firestore.pipeline.Expression regexFind(java.lang.String fieldName, java.lang.String pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that evaluates to a list of all substrings in a string expression that - * match a specified regular expression. - * - * This expression uses the [RE2](https://github.com/google/re2/wiki/Syntax) regular expression - * syntax. - * - * ```kotlin - * // Extract all matches based on a dynamic pattern expression - * regexFindAll(field("comment"), field("pattern")) - * ``` - * - * @param stringExpression The expression representing the string to search. - * @param pattern The regular expression to search for. - * @return A new [Expression] that evaluates to a list of matched substrings. - */ - -public com.google.firebase.firestore.pipeline.Expression regexFindAll(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that evaluates to a list of all substrings in a string expression that - * match a specified regular expression. - * - * This expression uses the [RE2](https://github.com/google/re2/wiki/Syntax) regular expression - * syntax. - * - * ```kotlin - * // Extract all mentions from a lower-cased comment - * regexFindAll(field("comment"), "@[A-Za-z0-9_]+") - * ``` - * - * @param stringExpression The expression representing the string to search. - * @param pattern The regular expression to search for. - * @return A new [Expression] that evaluates to a list of matched substrings. - */ - -public com.google.firebase.firestore.pipeline.Expression regexFindAll(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that evaluates to a list of all substrings in a string field that match - * a specified regular expression. - * - * This expression uses the [RE2](https://github.com/google/re2/wiki/Syntax) regular expression - * syntax. - * - * ```kotlin - * // Extract all matches from 'content' based on a pattern stored in another field - * regexFindAll("content", field("pattern")) - * ``` - * - * @param fieldName The name of the field containing the string to search. - * @param pattern The regular expression to search for. - * @return A new [Expression] that evaluates to a list of matched substrings. - */ - -public com.google.firebase.firestore.pipeline.Expression regexFindAll(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that evaluates to a list of all substrings in a string field that match - * a specified regular expression. - * - * This expression uses the [RE2](https://github.com/google/re2/wiki/Syntax) regular expression - * syntax. - * - * ```kotlin - * // Extract all hashtags from a post content field - * regexFindAll("content", "#[A-Za-z0-9_]+") - * ``` - * - * @param fieldName The name of the field containing the string to search. - * @param pattern The regular expression to search for. - * @return A new [Expression] that evaluates to a list of matched substrings. - */ - -public com.google.firebase.firestore.pipeline.Expression regexFindAll(java.lang.String fieldName, java.lang.String pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string field matches a specified regular expression. - * - * ```kotlin - * // Check if the 'email' field matches a valid email pattern - * regexMatch(field("email"), "[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}") - * ``` - * - * @param stringExpression The expression representing the string to match against. - * @param pattern The regular expression to use for the match. - * @return A new [BooleanExpression] representing the regular expression match comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression regexMatch(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string field matches a specified regular expression. - * - * ```kotlin - * // Check if the 'email' field matches a valid email pattern - * regexMatch(field("email"), "[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}") - * ``` - * - * @param stringExpression The expression representing the string to match against. - * @param pattern The regular expression to use for the match. - * @return A new [BooleanExpression] representing the regular expression match comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression regexMatch(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string field matches a specified regular expression. - * - * ```kotlin - * // Check if the 'email' field matches the regex from the 'pattern' field. - * regexMatch("email", field("pattern")) - * ``` - * - * @param fieldName The name of the field containing the string. - * @param pattern The regular expression to use for the match. - * @return A new [BooleanExpression] representing the regular expression match comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression regexMatch(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string field matches a specified regular expression. - * - * ```kotlin - * // Check if the 'email' field matches a valid email pattern - * regexMatch("email", "[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}") - * ``` - * - * @param fieldName The name of the field containing the string. - * @param pattern The regular expression to use for the match. - * @return A new [BooleanExpression] representing the regular expression match comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression regexMatch(java.lang.String fieldName, java.lang.String pattern) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the largest value between multiple input expressions or - * literal values. Based on Firestore's value type ordering. - * - * ```kotlin - * // Returns the larger value between the 'timestamp' field and the current timestamp. - * logicalMaximum(field("timestamp"), currentTimestamp()) - * ``` - * - * @param expr The first operand expression. - * @param others Optional additional expressions or literals. - * @return A new [Expression] representing the logical maximum operation. - */ - -public com.google.firebase.firestore.pipeline.Expression logicalMaximum(com.google.firebase.firestore.pipeline.Expression expr, java.lang.Object... others) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the largest value between multiple input expressions or - * literal values. Based on Firestore's value type ordering. - * - * ```kotlin - * // Returns the larger value between the 'timestamp' field and the current timestamp. - * logicalMaximum("timestamp", currentTimestamp()) - * ``` - * - * @param fieldName The first operand field name. - * @param others Optional additional expressions or literals. - * @return A new [Expression] representing the logical maximum operation. - */ - -public com.google.firebase.firestore.pipeline.Expression logicalMaximum(java.lang.String fieldName, java.lang.Object... others) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the smallest value between multiple input expressions or - * literal values. Based on Firestore's value type ordering. - * - * ```kotlin - * // Returns the smaller value between the 'timestamp' field and the current timestamp. - * logicalMinimum(field("timestamp"), currentTimestamp()) - * ``` - * - * @param expr The first operand expression. - * @param others Optional additional expressions or literals. - * @return A new [Expression] representing the logical minimum operation. - */ - -public com.google.firebase.firestore.pipeline.Expression logicalMinimum(com.google.firebase.firestore.pipeline.Expression expr, java.lang.Object... others) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the smallest value between multiple input expressions or - * literal values. Based on Firestore's value type ordering. - * - * ```kotlin - * // Returns the smaller value between the 'timestamp' field and the current timestamp. - * logicalMinimum("timestamp", currentTimestamp()) - * ``` - * - * @param fieldName The first operand field name. - * @param others Optional additional expressions or literals. - * @return A new [Expression] representing the logical minimum operation. - */ - -public com.google.firebase.firestore.pipeline.Expression logicalMinimum(java.lang.String fieldName, java.lang.Object... others) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that reverses a string. - * - * ```kotlin - * // Reverse the value of the 'myString' field. - * reverse(field("myString")) - * ``` - * - * @param stringExpression An expression evaluating to a string value, which will be reversed. - * @return A new [Expression] representing the reversed string. - */ - -public com.google.firebase.firestore.pipeline.Expression reverse(com.google.firebase.firestore.pipeline.Expression stringExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that reverses a string value from the specified field. - * - * ```kotlin - * // Reverse the value of the 'myString' field. - * reverse("myString") - * ``` - * - * @param fieldName The name of the field that contains the string to reverse. - * @return A new [Expression] representing the reversed string. - */ - -public com.google.firebase.firestore.pipeline.Expression reverse(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string expression contains a specified substring. - * - * ```kotlin - * // Check if the 'description' field contains the value of the 'keyword' field. - * stringContains(field("description"), field("keyword")) - * ``` - * - * @param stringExpression The expression representing the string to perform the comparison on. - * @param substring The expression representing the substring to search for. - * @return A new [BooleanExpression] representing the contains comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression stringContains(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression substring) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string expression contains a specified substring. - * - * ```kotlin - * // Check if the 'description' field contains "example". - * stringContains(field("description"), "example") - * ``` - * - * @param stringExpression The expression representing the string to perform the comparison on. - * @param substring The substring to search for. - * @return A new [BooleanExpression] representing the contains comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression stringContains(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String substring) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string field contains a specified substring. - * - * ```kotlin - * // Check if the 'description' field contains the value of the 'keyword' field. - * stringContains("description", field("keyword")) - * ``` - * - * @param fieldName The name of the field to perform the comparison on. - * @param substring The expression representing the substring to search for. - * @return A new [BooleanExpression] representing the contains comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression stringContains(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression substring) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string field contains a specified substring. - * - * ```kotlin - * // Check if the 'description' field contains "example". - * stringContains("description", "example") - * ``` - * - * @param fieldName The name of the field to perform the comparison on. - * @param substring The substring to search for. - * @return A new [BooleanExpression] representing the contains comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression stringContains(java.lang.String fieldName, java.lang.String substring) { throw new RuntimeException("Stub!"); } - -/** - * ```kotlin - * // Check if the 'fullName' field starts with the value of the 'firstName' field - * startsWith(field("fullName"), field("firstName")) - * ``` - * - * @param stringExpr The expression to check. - * @param prefix The prefix string expression to check for. - * @return A new [BooleanExpression] representing the 'starts with' comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression startsWith(com.google.firebase.firestore.pipeline.Expression stringExpr, com.google.firebase.firestore.pipeline.Expression prefix) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string expression starts with a given [prefix]. - * - * ```kotlin - * // Check if the 'name' field starts with "Mr." - * startsWith(field("name"), "Mr.") - * ``` - * - * @param stringExpr The expression to check. - * @param prefix The prefix string to check for. - * @return A new [BooleanExpression] representing the 'starts with' comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression startsWith(com.google.firebase.firestore.pipeline.Expression stringExpr, java.lang.String prefix) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string expression starts with a given [prefix]. - * - * ```kotlin - * // Check if the 'fullName' field starts with the value of the 'firstName' field - * startsWith("fullName", field("firstName")) - * ``` - * - * @param fieldName The name of field that contains a string to check. - * @param prefix The prefix string expression to check for. - * @return A new [BooleanExpression] representing the 'starts with' comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression startsWith(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression prefix) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string expression starts with a given [prefix]. - * - * ```kotlin - * // Check if the 'name' field starts with "Mr." - * startsWith("name", "Mr.") - * ``` - * - * @param fieldName The name of field that contains a string to check. - * @param prefix The prefix string to check for. - * @return A new [BooleanExpression] representing the 'starts with' comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression startsWith(java.lang.String fieldName, java.lang.String prefix) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string expression ends with a given [suffix]. - * - * ```kotlin - * // Check if the 'url' field ends with the value of the 'extension' field - * endsWith(field("url"), field("extension")) - * ``` - * - * @param stringExpr The expression to check. - * @param suffix The suffix string expression to check for. - * @return A new [BooleanExpression] representing the 'ends with' comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression endsWith(com.google.firebase.firestore.pipeline.Expression stringExpr, com.google.firebase.firestore.pipeline.Expression suffix) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string expression ends with a given [suffix]. - * - * ```kotlin - * // Check if the 'filename' field ends with ".txt" - * endsWith(field("filename"), ".txt") - * ``` - * - * @param stringExpr The expression to check. - * @param suffix The suffix string to check for. - * @return A new [BooleanExpression] representing the 'ends with' comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression endsWith(com.google.firebase.firestore.pipeline.Expression stringExpr, java.lang.String suffix) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string expression ends with a given [suffix]. - * - * ```kotlin - * // Check if the 'url' field ends with the value of the 'extension' field - * endsWith("url", field("extension")) - * ``` - * - * @param fieldName The name of field that contains a string to check. - * @param suffix The suffix string expression to check for. - * @return A new [BooleanExpression] representing the 'ends with' comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression endsWith(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression suffix) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a string expression ends with a given [suffix]. - * - * ```kotlin - * // Check if the 'filename' field ends with ".txt" - * endsWith("filename", ".txt") - * ``` - * - * @param fieldName The name of field that contains a string to check. - * @param suffix The suffix string to check for. - * @return A new [BooleanExpression] representing the 'ends with' comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression endsWith(java.lang.String fieldName, java.lang.String suffix) { throw new RuntimeException("Stub!"); } - -/** - * Reverses the given string expression. - * - * ```kotlin - * // Reverse the value of the 'myString' field. - * stringReverse(field("myString")) - * ``` - * - * @param str The string expression to reverse. - * @return A new [Expression] representing the stringReverse operation. - */ - -public com.google.firebase.firestore.pipeline.Expression stringReverse(com.google.firebase.firestore.pipeline.Expression str) { throw new RuntimeException("Stub!"); } - -/** - * Reverses the given string field. - * - * ```kotlin - * // Reverse the value of the 'myString' field. - * stringReverse("myString") - * ``` - * - * @param fieldName The name of field that contains the string to reverse. - * @return A new [Expression] representing the stringReverse operation. - */ - -public com.google.firebase.firestore.pipeline.Expression stringReverse(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a substring of the given string. - * - * ```kotlin - * // Get a substring of the 'message' field starting at index 5 with length 10. - * substring(field("message"), constant(5), constant(10)) - * ``` - * - * @param stringExpression The expression representing the string to get a substring from. - * @param index The starting index of the substring. - * @param length The length of the substring. - * @return A new [Expression] representing the substring. - */ - -public com.google.firebase.firestore.pipeline.Expression substring(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression index, com.google.firebase.firestore.pipeline.Expression length) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a substring of the given string. - * - * ```kotlin - * // Get a substring of the 'message' field starting at index 5 with length 10. - * substring("message", 5, 10) - * ``` - * - * @param fieldName The name of the field containing the string to get a substring from. - * @param index The starting index of the substring. - * @param length The length of the substring. - * @return A new [Expression] representing the substring. - */ - -public com.google.firebase.firestore.pipeline.Expression substring(java.lang.String fieldName, int index, int length) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that converts a string expression to lowercase. - * - * ```kotlin - * // Convert the 'name' field to lowercase - * toLower(field("name")) - * ``` - * - * @param stringExpression The expression representing the string to convert to lowercase. - * @return A new [Expression] representing the lowercase string. - */ - -public com.google.firebase.firestore.pipeline.Expression toLower(com.google.firebase.firestore.pipeline.Expression stringExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that converts a string field to lowercase. - * - * ```kotlin - * // Convert the 'name' field to lowercase - * toLower("name") - * ``` - * - * @param fieldName The name of the field containing the string to convert to lowercase. - * @return A new [Expression] representing the lowercase string. - */ - -public com.google.firebase.firestore.pipeline.Expression toLower(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that converts a string expression to uppercase. - * - * ```kotlin - * // Convert the 'title' field to uppercase - * toUpper(field("title")) - * ``` - * - * @param stringExpression The expression representing the string to convert to uppercase. - * @return A new [Expression] representing the uppercase string. - */ - -public com.google.firebase.firestore.pipeline.Expression toUpper(com.google.firebase.firestore.pipeline.Expression stringExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that converts a string field to uppercase. - * - * ```kotlin - * // Convert the 'title' field to uppercase - * toUpper("title") - * ``` - * - * @param fieldName The name of the field containing the string to convert to uppercase. - * @return A new [Expression] representing the uppercase string. - */ - -public com.google.firebase.firestore.pipeline.Expression toUpper(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes leading and trailing whitespace from a string expression. - * - * ```kotlin - * // Trim whitespace from the 'userInput' field - * trim(field("userInput")) - * ``` - * - * @param stringExpression The expression representing the string to trim. - * @return A new [Expression] representing the trimmed string. - */ - -public com.google.firebase.firestore.pipeline.Expression trim(com.google.firebase.firestore.pipeline.Expression stringExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes leading and trailing whitespace from a string field. - * - * ```kotlin - * // Trim whitespace from the 'userInput' field - * trim("userInput") - * ``` - * - * @param fieldName The name of the field containing the string to trim. - * @return A new [Expression] representing the trimmed string. - */ - -public com.google.firebase.firestore.pipeline.Expression trim(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes a set of leading and trailing values from an expression. - * - * Note: The values to trim are treated as a **set**, not a substring. - * - * ```kotlin - * // Trim specified characters from the 'userInput' field - * trimValue(field("userInput"), field("valueToTrim")) - * ``` - * - * @param stringExpression The expression representing the string to trim. - * @param valueToTrim The expression evaluated to either a string or a blob. This parameter is - * treated as a set of characters or bytes that will be matched against the input from both - * ends. - * @return A new [Expression] representing the trimmed string or bytes. - */ - -public com.google.firebase.firestore.pipeline.Expression trimValue(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression valueToTrim) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes a set of leading and trailing values from a string field. - * - * Note: The values to trim are treated as a **set**, not a substring. - * - * ```kotlin - * // Trim all '-', and '_' characters from the beginning and the end of 'userInput' field - * trimValue("userInput", "-_") - * ``` - * - * @param fieldName The name of the field containing the string to trim. - * @param valueToTrim This parameter is treated as a set of characters or bytes that will be - * matched against the input from both ends. - * @return A new [Expression] representing the trimmed string. - */ - -public com.google.firebase.firestore.pipeline.Expression trimValue(java.lang.String fieldName, java.lang.String valueToTrim) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes leading whitespace from a string expression. - * - * ```kotlin - * // Trim leading whitespace from the 'text' field. - * ltrim(field("text")) - * ``` - * - * @param stringExpression The expression representing the string to trim. - * @return A new [Expression] representing the ltrim operation. - */ - -public com.google.firebase.firestore.pipeline.Expression ltrim(com.google.firebase.firestore.pipeline.Expression stringExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes leading whitespace from a string field. - * - * ```kotlin - * // Trim leading whitespace from the 'text' field. - * ltrim("text") - * ``` - * - * @param fieldName The name of the field containing the string to trim. - * @return A new [Expression] representing the ltrim operation. - */ - -public com.google.firebase.firestore.pipeline.Expression ltrim(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes a set of leading values from a string expression. - * - * Note: The values to trim are treated as a **set**, not a substring. - * - * ```kotlin - * // Trim all leading '-' and '_' characters from the 'text' field. - * ltrimValue(field("text"), "-_") - * ``` - * - * @param stringExpression The expression representing the string to trim. - * @param valuesToTrim The set of values to remove. - * @return A new [Expression] representing the ltrim operation. - */ - -public com.google.firebase.firestore.pipeline.Expression ltrimValue(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String valuesToTrim) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes a set of leading values from a string expression. - * - * Note: The values to trim are treated as a **set**, not a substring. - * - * ```kotlin - * // Trim leading characters defined by the 'chars' field from the 'text' field. - * ltrimValue(field("text"), field("chars")) - * ``` - * - * @param stringExpression The expression representing the string to trim. - * @param valuesToTrim The expression representing the set of values to remove. - * @return A new [Expression] representing the ltrim operation. - */ - -public com.google.firebase.firestore.pipeline.Expression ltrimValue(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression valuesToTrim) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes specified leading values from a string field. - * - * Note: The values to trim are treated as a **set**, not a substring. - * - * ```kotlin - * // Trim all leading '-' and '_' characters from the 'text' field. - * ltrimValue("text", "-_") - * ``` - * - * @param fieldName The name of the field containing the string to trim. - * @param valuesToTrim The set of values to remove. - * @return A new [Expression] representing the ltrim operation. - */ - -public com.google.firebase.firestore.pipeline.Expression ltrimValue(java.lang.String fieldName, java.lang.String valuesToTrim) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes specified leading values from a string field. - * - * Note: The values to trim are treated as a **set**, not a substring. - * - * ```kotlin - * // Trim leading characters defined by the 'chars' field from the 'text' field. - * ltrimValue("text", field("chars")) - * ``` - * - * @param fieldName The name of the field containing the string to trim. - * @param valuesToTrim The expression representing the set of values to remove. - * @return A new [Expression] representing the ltrim operation. - */ - -public com.google.firebase.firestore.pipeline.Expression ltrimValue(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression valuesToTrim) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes trailing whitespace from a string expression. - * - * ```kotlin - * // Trim trailing whitespace from the 'text' field. - * rtrim(field("text")) - * ``` - * - * @param stringExpression The expression representing the string to trim. - * @return A new [Expression] representing the rtrim operation. - */ - -public com.google.firebase.firestore.pipeline.Expression rtrim(com.google.firebase.firestore.pipeline.Expression stringExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes trailing whitespace from a string field. - * - * ```kotlin - * // Trim trailing whitespace from the 'text' field. - * rtrim("text") - * ``` - * - * @param fieldName The name of the field containing the string to trim. - * @return A new [Expression] representing the rtrim operation. - */ - -public com.google.firebase.firestore.pipeline.Expression rtrim(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes a set of trailing values from a string expression. - * - * Note: The values to trim are treated as a **set**, not a substring. - * - * ```kotlin - * // Trim all trailing '-' and '_' characters from the 'text' field. - * rtrimValue(field("text"), "-_") - * ``` - * - * @param stringExpression The expression representing the string to trim. - * @param valuesToTrim The set of values to remove. - * @return A new [Expression] representing the rtrim operation. - */ - -public com.google.firebase.firestore.pipeline.Expression rtrimValue(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String valuesToTrim) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes a set of trailing values from a string expression. - * - * Note: The values to trim are treated as a **set**, not a substring. - * - * ```kotlin - * // Trim trailing characters defined by the 'chars' field from the 'text' field. - * rtrimValue(field("text"), field("chars")) - * ``` - * - * @param stringExpression The expression representing the string to trim. - * @param valuesToTrim The expression representing the set of values to remove. - * @return A new [Expression] representing the rtrim operation. - */ - -public com.google.firebase.firestore.pipeline.Expression rtrimValue(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression valuesToTrim) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes a set of trailing values from a string field. - * - * Note: The values to trim are treated as a **set**, not a substring. - * - * ```kotlin - * // Trim all trailing '-' and '_' characters from the 'text' field. - * rtrimValue("text", "-_") - * ``` - * - * @param fieldName The name of the field containing the string to trim. - * @param valuesToTrim The set of values to remove. - * @return A new [Expression] representing the rtrim operation. - */ - -public com.google.firebase.firestore.pipeline.Expression rtrimValue(java.lang.String fieldName, java.lang.String valuesToTrim) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes a set of trailing values from a string field. - * - * Note: The values to trim are treated as a **set**, not a substring. - * - * ```kotlin - * // Trim trailing characters defined by the 'chars' field from the 'text' field. - * rtrimValue("text", field("chars")) - * ``` - * - * @param fieldName The name of the field containing the string to trim. - * @param valuesToTrim The expression representing the set of values to remove. - * @return A new [Expression] representing the rtrim operation. - */ - -public com.google.firebase.firestore.pipeline.Expression rtrimValue(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression valuesToTrim) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that repeats a string expression a given number of times. - * - * ```kotlin - * // Repeat the 'name' field 3 times. - * stringRepeat(field("name"), 3) - * ``` - * - * @param stringExpression The expression representing the string to repeat. - * @param count The number of times to repeat the string. - * @return A new [Expression] representing the stringRepeat operation. - */ - -public com.google.firebase.firestore.pipeline.Expression stringRepeat(com.google.firebase.firestore.pipeline.Expression stringExpression, int count) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that repeats a string expression a given number of times. - * - * ```kotlin - * // Repeat the 'name' field the number of times specified in the 'count' field. - * stringRepeat(field("name"), field("count")) - * ``` - * - * @param stringExpression The expression representing the string to repeat. - * @param count The expression representing the number of times to repeat the string. - * @return A new [Expression] representing the stringRepeat operation. - */ - -public com.google.firebase.firestore.pipeline.Expression stringRepeat(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression count) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that repeats a string field a given number of times. - * - * ```kotlin - * // Repeat the 'name' field 3 times. - * stringRepeat("name", 3) - * ``` - * - * @param fieldName The name of the field containing the string to repeat. - * @param count The number of times to repeat the string. - * @return A new [Expression] representing the stringRepeat operation. - */ - -public com.google.firebase.firestore.pipeline.Expression stringRepeat(java.lang.String fieldName, int count) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that repeats a string field a given number of times. - * - * ```kotlin - * // Repeat the 'name' field the number of times specified in the 'count' field. - * stringRepeat("name", field("count")) - * ``` - * - * @param fieldName The name of the field containing the string to repeat. - * @param count The expression representing the number of times to repeat the string. - * @return A new [Expression] representing the stringRepeat operation. - */ - -public com.google.firebase.firestore.pipeline.Expression stringRepeat(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression count) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that replaces all occurrences of a substring with another string. - * - * ```kotlin - * // Replace all occurrences of the 'old' field with the 'new' field in 'text'. - * stringReplaceAll(field("text"), field("old"), field("new")) - * ``` - * - * @param stringExpression The expression representing the original string. - * @param oldValue The expression representing the substring to replace. - * @param newValue The expression representing the replacement string. - * @return A new [Expression] representing the stringReplaceAll operation. - */ - -public com.google.firebase.firestore.pipeline.Expression stringReplaceAll(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression oldValue, com.google.firebase.firestore.pipeline.Expression newValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that replaces all occurrences of a substring with another string. - * - * ```kotlin - * // Replace all occurrences of "cat" with "dog" in the 'text' field. - * stringReplaceAll(field("text"), "cat", "dog") - * ``` - * - * @param stringExpression The expression representing the original string. - * @param oldValue The substring to replace. - * @param newValue The replacement string. - * @return A new [Expression] representing the stringReplaceAll operation. - */ - -public com.google.firebase.firestore.pipeline.Expression stringReplaceAll(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String oldValue, java.lang.String newValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that replaces all occurrences of a substring with another string in a - * field. - * - * ```kotlin - * // Replace all occurrences of the 'old' field with the 'new' field in 'text'. - * stringReplaceAll("text", field("old"), field("new")) - * ``` - * - * @param fieldName The name of the field containing the original string. - * @param oldValue The expression representing the substring to replace. - * @param newValue The expression representing the replacement string. - * @return A new [Expression] representing the stringReplaceAll operation. - */ - -public com.google.firebase.firestore.pipeline.Expression stringReplaceAll(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression oldValue, com.google.firebase.firestore.pipeline.Expression newValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that replaces all occurrences of a substring with another string in a - * field. - * - * ```kotlin - * // Replace all occurrences of "cat" with "dog" in the 'text' field. - * stringReplaceAll("text", "cat", "dog") - * ``` - * - * @param fieldName The name of the field containing the original string. - * @param oldValue The substring to replace. - * @param newValue The replacement string. - * @return A new [Expression] representing the stringReplaceAll operation. - */ - -public com.google.firebase.firestore.pipeline.Expression stringReplaceAll(java.lang.String fieldName, java.lang.String oldValue, java.lang.String newValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that replaces the first occurrence of a substring with another string. - * - * ```kotlin - * // Replace the first occurrence of the 'old' field with the 'new' field in 'text'. - * stringReplaceOne(field("text"), field("old"), field("new")) - * ``` - * - * @param stringExpression The expression representing the original string. - * @param oldValue The expression representing the substring to replace. - * @param newValue The expression representing the replacement string. - * @return A new [Expression] representing the stringReplaceOne operation. - */ - -public com.google.firebase.firestore.pipeline.Expression stringReplaceOne(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression oldValue, com.google.firebase.firestore.pipeline.Expression newValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that replaces the first occurrence of a substring with another string. - * - * ```kotlin - * // Replace the first occurrence of "cat" with "dog" in the 'text' field. - * stringReplaceOne(field("text"), "cat", "dog") - * ``` - * - * @param stringExpression The expression representing the original string. - * @param oldValue The substring to replace. - * @param newValue The replacement string. - * @return A new [Expression] representing the stringReplaceOne operation. - */ - -public com.google.firebase.firestore.pipeline.Expression stringReplaceOne(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String oldValue, java.lang.String newValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that replaces the first occurrence of a substring with another string - * in a field. - * - * ```kotlin - * // Replace the first occurrence of the 'old' field with the 'new' field in 'text'. - * stringReplaceOne("text", field("old"), field("new")) - * ``` - * - * @param fieldName The name of the field containing the original string. - * @param oldValue The expression representing the substring to replace. - * @param newValue The expression representing the replacement string. - * @return A new [Expression] representing the stringReplaceOne operation. - */ - -public com.google.firebase.firestore.pipeline.Expression stringReplaceOne(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression oldValue, com.google.firebase.firestore.pipeline.Expression newValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that replaces the first occurrence of a substring with another string - * in a field. - * - * ```kotlin - * // Replace the first occurrence of "cat" with "dog" in the 'text' field. - * stringReplaceOne("text", "cat", "dog") - * ``` - * - * @param fieldName The name of the field containing the original string. - * @param oldValue The substring to replace. - * @param newValue The replacement string. - * @return A new [Expression] representing the stringReplaceOne operation. - */ - -public com.google.firebase.firestore.pipeline.Expression stringReplaceOne(java.lang.String fieldName, java.lang.String oldValue, java.lang.String newValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the 0-based index of the first occurrence of the specified - * substring. - * - * ```kotlin - * // Get the index of the 'search' field within the 'text' field. - * stringIndexOf(field("text"), field("search")) - * ``` - * - * @param stringExpression The expression representing the string to search within. - * @param substring The expression representing the substring to search for. - * @return A new [Expression] representing the stringIndexOf operation. - */ - -public com.google.firebase.firestore.pipeline.Expression stringIndexOf(com.google.firebase.firestore.pipeline.Expression stringExpression, com.google.firebase.firestore.pipeline.Expression substring) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the 0-based index of the first occurrence of the specified - * substring. - * - * ```kotlin - * // Get the index of "world" within the 'text' field. - * stringIndexOf(field("text"), "world") - * ``` - * - * @param stringExpression The expression representing the string to search within. - * @param substring The substring to search for. - * @return A new [Expression] representing the stringIndexOf operation. - */ - -public com.google.firebase.firestore.pipeline.Expression stringIndexOf(com.google.firebase.firestore.pipeline.Expression stringExpression, java.lang.String substring) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the 0-based index of the first occurrence of the specified - * substring in a field. - * - * ```kotlin - * // Get the index of the 'search' field within the 'text' field. - * stringIndexOf("text", field("search")) - * ``` - * - * @param fieldName The name of the field containing the string to search within. - * @param substring The expression representing the substring to search for. - * @return A new [Expression] representing the stringIndexOf operation. - */ - -public com.google.firebase.firestore.pipeline.Expression stringIndexOf(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression substring) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the 0-based index of the first occurrence of the specified - * substring in a field. - * - * ```kotlin - * // Get the index of "world" within the 'text' field. - * stringIndexOf("text", "world") - * ``` - * - * @param fieldName The name of the field containing the string to search within. - * @param substring The substring to search for. - * @return A new [Expression] representing the stringIndexOf operation. - */ - -public com.google.firebase.firestore.pipeline.Expression stringIndexOf(java.lang.String fieldName, java.lang.String substring) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that concatenates string expressions together. - * - * ```kotlin - * // Combine the 'firstName', " ", and 'lastName' fields into a single string - * stringConcat(field("firstName"), constant(" "), field("lastName")) - * ``` - * - * @param firstString The expression representing the initial string value. - * @param otherStrings Optional additional string expressions to concatenate. - * @return A new [Expression] representing the concatenated string. - */ - -public com.google.firebase.firestore.pipeline.Expression stringConcat(com.google.firebase.firestore.pipeline.Expression firstString, com.google.firebase.firestore.pipeline.Expression... otherStrings) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that concatenates string expressions together. - * - * ```kotlin - * // Combine the 'firstName', " ", and 'lastName' fields into a single string - * stringConcat(field("firstName"), " ", field("lastName")) - * ``` - * - * @param firstString The expression representing the initial string value. - * @param otherStrings Optional additional string expressions or string constants to - * concatenate. - * @return A new [Expression] representing the concatenated string. - */ - -public com.google.firebase.firestore.pipeline.Expression stringConcat(com.google.firebase.firestore.pipeline.Expression firstString, java.lang.Object... otherStrings) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that concatenates string expressions together. - * - * ```kotlin - * // Combine the 'firstName', " ", and 'lastName' fields into a single string - * stringConcat("firstName", constant(" "), field("lastName")) - * ``` - * - * @param fieldName The field name containing the initial string value. - * @param otherStrings Optional additional string expressions to concatenate. - * @return A new [Expression] representing the concatenated string. - */ - -public com.google.firebase.firestore.pipeline.Expression stringConcat(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression... otherStrings) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that concatenates string expressions together. - * - * ```kotlin - * // Combine the 'firstName', " ", and 'lastName' fields into a single string - * stringConcat("firstName", " ", "lastName") - * ``` - * - * @param fieldName The field name containing the initial string value. - * @param otherStrings Optional additional string expressions or string constants to - * concatenate. - * @return A new [Expression] representing the concatenated string. - */ - -public com.google.firebase.firestore.pipeline.Expression stringConcat(java.lang.String fieldName, java.lang.Object... otherStrings) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that creates a Firestore map value from an input object. - * - * ```kotlin - * // Create a map with a constant key and a field value - * map(mapOf("name" to field("productName"), "quantity" to 1)) - * ``` - * - * @param elements The input map to evaluate in the expression. - * @return A new [Expression] representing the map function. - */ - -public com.google.firebase.firestore.pipeline.Expression map(java.util.Map elements) { throw new RuntimeException("Stub!"); } - -/** - * Accesses a field/property of a document or Map using the provided [key]. - * - * @param expression The expression evaluating to a map or document. - * @param key The key of the field to access. - * @return An [Expression] representing the value of the field. - */ - -public com.google.firebase.firestore.pipeline.Expression getField(com.google.firebase.firestore.pipeline.Expression expression, java.lang.String key) { throw new RuntimeException("Stub!"); } - -/** - * Accesses a field/property of a document or Map using the provided [key]. - * - * @param fieldName The field name of the map or document field. - * @param key The key of the field to access. - * @return An [Expression] representing the value of the field. - */ - -public com.google.firebase.firestore.pipeline.Expression getField(java.lang.String fieldName, java.lang.String key) { throw new RuntimeException("Stub!"); } - -/** - * Accesses a field/property of a document or Map using the provided [keyExpression]. - * - * @param expression The expression evaluating to a Map or Document. - * @param keyExpression The expression evaluating to the key. - * @return A new [Expression] representing the value of the field. - */ - -public com.google.firebase.firestore.pipeline.Expression getField(com.google.firebase.firestore.pipeline.Expression expression, com.google.firebase.firestore.pipeline.Expression keyExpression) { throw new RuntimeException("Stub!"); } - -/** - * Accesses a field/property of a document or Map using the provided [keyExpression]. - * - * @param fieldName The field name of the map or document field. - * @param keyExpression The expression evaluating to the key. - * @return A new [Expression] representing the value of the field. - */ - -public com.google.firebase.firestore.pipeline.Expression getField(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression keyExpression) { throw new RuntimeException("Stub!"); } - -/** - * Accesses a value from a map (object) field using the provided [key]. - * - * ```kotlin - * // Get the 'city' value from the 'address' map field - * mapGet(field("address"), "city") - * ``` - * - * @param mapExpression The expression representing the map. - * @param key The key to access in the map. - * @return A new [Expression] representing the value associated with the given key in the map. - */ - -public com.google.firebase.firestore.pipeline.Expression mapGet(com.google.firebase.firestore.pipeline.Expression mapExpression, java.lang.String key) { throw new RuntimeException("Stub!"); } - -/** - * Accesses a value from a map (object) field using the provided [key]. - * - * ```kotlin - * // Get the 'city' value from the 'address' map field - * mapGet("address", "city") - * ``` - * - * @param fieldName The field name of the map field. - * @param key The key to access in the map. - * @return A new [Expression] representing the value associated with the given key in the map. - */ - -public com.google.firebase.firestore.pipeline.Expression mapGet(java.lang.String fieldName, java.lang.String key) { throw new RuntimeException("Stub!"); } - -/** - * Accesses a value from a map (object) field using the provided [keyExpression]. - * - * ```kotlin - * // Get the value from the 'address' map field, using the key from the 'keyField' field - * mapGet(field("address"), field("keyField")) - * ``` - * - * @param mapExpression The expression representing the map. - * @param keyExpression The key to access in the map. - * @return A new [Expression] representing the value associated with the given key in the map. - */ - -public com.google.firebase.firestore.pipeline.Expression mapGet(com.google.firebase.firestore.pipeline.Expression mapExpression, com.google.firebase.firestore.pipeline.Expression keyExpression) { throw new RuntimeException("Stub!"); } - -/** - * Accesses a value from a map (object) field using the provided [keyExpression]. - * - * ```kotlin - * // Get the value from the 'address' map field, using the key from the 'keyField' field - * mapGet("address", field("keyField")) - * ``` - * - * @param fieldName The field name of the map field. - * @param keyExpression The key to access in the map. - * @return A new [Expression] representing the value associated with the given key in the map. - */ - -public com.google.firebase.firestore.pipeline.Expression mapGet(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression keyExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that merges multiple maps into a single map. If multiple maps have the - * same key, the later value is used. - * - * ```kotlin - * // Merges the map in the settings field with, a map literal, and a map in - * // that is conditionally returned by another expression - * mapMerge( - * field("settings"), - * map(mapOf("enabled" to true)), - * conditional( - * field("isAdmin").equal(true), - * map(mapOf("admin" to true)), - * map(emptyMap()) - * ) - * ) - * ``` - * - * @param firstMap First map expression that will be merged. - * @param secondMap Second map expression that will be merged. - * @param otherMaps Additional maps to merge. - * @return A new [Expression] representing the mapMerge operation. - */ - -public com.google.firebase.firestore.pipeline.Expression mapMerge(com.google.firebase.firestore.pipeline.Expression firstMap, com.google.firebase.firestore.pipeline.Expression secondMap, com.google.firebase.firestore.pipeline.Expression... otherMaps) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that merges multiple maps into a single map. If multiple maps have the - * same key, the later value is used. - * - * ```kotlin - * // Merges the map in the settings field with, a map literal, and a map in - * // that is conditionally returned by another expression - * mapMerge( - * "settings", - * map(mapOf("enabled" to true)), - * conditional( - * field("isAdmin").equal(true), - * map(mapOf("admin" to true)), - * map(emptyMap()) - * ) - * ) - * ``` - * - * @param firstMapFieldName First map field name that will be merged. - * @param secondMap Second map expression that will be merged. - * @param otherMaps Additional maps to merge. - * @return A new [Expression] representing the mapMerge operation. - */ - -public com.google.firebase.firestore.pipeline.Expression mapMerge(java.lang.String firstMapFieldName, com.google.firebase.firestore.pipeline.Expression secondMap, com.google.firebase.firestore.pipeline.Expression... otherMaps) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes a key from the map produced by evaluating an expression. - * - * ```kotlin - * // Removes the key 'baz' from the input map. - * mapRemove(map(mapOf("foo" to "bar", "baz" to true)), constant("baz")) - * ``` - * - * @param mapExpr An expression that evaluates to a map. - * @param key The name of the key to remove from the input map. - * @return A new [Expression] that evaluates to a modified map. - */ - -public com.google.firebase.firestore.pipeline.Expression mapRemove(com.google.firebase.firestore.pipeline.Expression mapExpr, com.google.firebase.firestore.pipeline.Expression key) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes a key from the map produced by evaluating an expression. - * - * ```kotlin - * // Removes the key 'city' field from the map in the address field of the input document. - * mapRemove("address", constant("city")) - * ``` - * - * @param mapField The name of a field containing a map value. - * @param key The name of the key to remove from the input map. - * @return A new [Expression] that evaluates to a modified map. - */ - -public com.google.firebase.firestore.pipeline.Expression mapRemove(java.lang.String mapField, com.google.firebase.firestore.pipeline.Expression key) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes a key from the map produced by evaluating an expression. - * - * ```kotlin - * // Removes the key 'baz' from the input map. - * mapRemove(map(mapOf("foo" to "bar", "baz" to true)), "baz") - * ``` - * - * @param mapExpr An expression that evaluates to a map. - * @param key The name of the key to remove from the input map. - * @return A new [Expression] that evaluates to a modified map. - */ - -public com.google.firebase.firestore.pipeline.Expression mapRemove(com.google.firebase.firestore.pipeline.Expression mapExpr, java.lang.String key) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that removes a key from the map produced by evaluating an expression. - * - * ```kotlin - * // Removes the key 'city' field from the map in the address field of the input document. - * mapRemove("address", "city") - * ``` - * - * @param mapField The name of a field containing a map value. - * @param key The name of the key to remove from the input map. - * @return A new [Expression] that evaluates to a modified map. - */ - -public com.google.firebase.firestore.pipeline.Expression mapRemove(java.lang.String mapField, java.lang.String key) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a new map with the specified entries added or updated. - * - * Note: This only performs shallow updates to the map. Setting a value to `null` will retain - * the key with a `null` value. To remove a key entirely, use `mapRemove`. - * - * ```kotlin - * // Set the 'city' to "San Francisco" in the 'address' map - * mapSet(field("address"), constant("city"), constant("San Francisco")); - * ``` - * - * @param mapExpr The expression representing the map. - * @param key The key to set. Must be an expression representing a string. - * @param value The value to set. - * @param moreKeyValues Additional key-value pairs to set. - * @return A new [Expression] representing the map with the entries set. - */ - -public com.google.firebase.firestore.pipeline.Expression mapSet(com.google.firebase.firestore.pipeline.Expression mapExpr, com.google.firebase.firestore.pipeline.Expression key, com.google.firebase.firestore.pipeline.Expression value, com.google.firebase.firestore.pipeline.Expression... moreKeyValues) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a new map with the specified entries added or updated. - * - * Note: This only performs shallow updates to the map. Setting a value to `null` will retain - * the key with a `null` value. To remove a key entirely, use `mapRemove`. - * - * ```kotlin - * // Set the 'city' to "San Francisco" in the 'address' map - * mapSet(field("address"), "city", "San Francisco"); - * ``` - * - * @param mapExpr The map field to set entries in. - * @param key The key to set. - * @param value The value to set. - * @param moreKeyValues Additional key-value pairs to set. - * @return A new [Expression] representing the map with the entries set. - */ - -public com.google.firebase.firestore.pipeline.Expression mapSet(com.google.firebase.firestore.pipeline.Expression mapExpr, java.lang.String key, java.lang.Object value, java.lang.Object... moreKeyValues) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a new map with the specified entries added or updated. - * - * Note: This only performs shallow updates to the map. Setting a value to `null` will retain - * the key with a `null` value. To remove a key entirely, use `mapRemove`. - * - * ```kotlin - * // Set the 'city' to "San Francisco" in the 'address' map - * mapSet("address", constant("city"), constant("San Francisco")) - * ``` - * - * @param mapField The map field to set entries in. - * @param key The key to set. Must be an expression representing a string. - * @param value The value to set. - * @param moreKeyValues Additional key-value pairs to set. - * @return A new [Expression] representing the map with the entries set. - */ - -public com.google.firebase.firestore.pipeline.Expression mapSet(java.lang.String mapField, com.google.firebase.firestore.pipeline.Expression key, com.google.firebase.firestore.pipeline.Expression value, com.google.firebase.firestore.pipeline.Expression... moreKeyValues) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a new map with the specified entries added or updated. - * - * Note: This only performs shallow updates to the map. Setting a value to `null` will retain - * the key with a `null` value. To remove a key entirely, use `mapRemove`. - * - * ```kotlin - * // Set the 'city' to "San Francisco" in the 'address' map - * mapSet("address", "city", "San Francisco") - * ``` - * - * @param mapField The map field to set entries in. - * @param key The key to set. Must be an expression representing a string. - * @param value The value to set. - * @param moreKeyValues Additional key-value pairs to set. - * @return A new [Expression] representing the map with the entries set. - */ - -public com.google.firebase.firestore.pipeline.Expression mapSet(java.lang.String mapField, java.lang.String key, java.lang.Object value, java.lang.Object... moreKeyValues) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the keys of a map. - * - * Note: While the backend generally preserves insertion order, relying on the order of the - * output array is not guaranteed and should be avoided. - * - * ```kotlin - * // Get the keys of a map expression. - * mapKeys(map(mapOf("a" to 1, "b" to 2))) - * ``` - * - * @param mapExpr The expression representing the map to get the keys of. - * @return A new [Expression] representing the keys of the map. - */ - -public com.google.firebase.firestore.pipeline.Expression mapKeys(com.google.firebase.firestore.pipeline.Expression mapExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the keys of a map. - * - * Note: While the backend generally preserves insertion order, relying on the order of the - * output array is not guaranteed and should be avoided. - * - * ```kotlin - * // Get the keys of the 'metadata' map field. - * mapKeys("metadata") - * ``` - * - * @param mapField The map field to get the keys of. - * @return A new [Expression] representing the keys of the map. - */ - -public com.google.firebase.firestore.pipeline.Expression mapKeys(java.lang.String mapField) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the values of a map. - * - * Note: While the backend generally preserves insertion order, relying on the order of the - * output array is not guaranteed and should be avoided. - * - * ```kotlin - * // Get the values of a map expression. - * mapValues(map(mapOf("a" to 1, "b" to 2))) - * ``` - * - * @param mapExpr The expression representing the map to get the values of. - * @return A new [Expression] representing the values of the map. - */ - -public com.google.firebase.firestore.pipeline.Expression mapValues(com.google.firebase.firestore.pipeline.Expression mapExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the values of a map. - * - * Note: While the backend generally preserves insertion order, relying on the order of the - * output array is not guaranteed and should be avoided. - * - * ```kotlin - * // Get the values of the 'metadata' map field. - * mapValues("metadata") - * ``` - * - * @param mapField The map field to get the values of. - * @return A new [Expression] representing the values of the map. - */ - -public com.google.firebase.firestore.pipeline.Expression mapValues(java.lang.String mapField) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the entries of a map as an array of maps, where each map - * contains a "k" property for the key and a "v" property for the value. - * - * Note: While the backend generally preserves insertion order, relying on the order of the - * output array is not guaranteed and should be avoided. - * - * ```kotlin - * // Get the entries of a map expression. - * mapEntries(map(mapOf("a" to 1, "b" to 2))) - * ``` - * - * @param mapExpr The expression representing the map to get the entries of. - * @return A new [Expression] representing the entries of the map. - */ - -public com.google.firebase.firestore.pipeline.Expression mapEntries(com.google.firebase.firestore.pipeline.Expression mapExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the entries of a map as an array of maps. - * - * Note: While the backend generally preserves insertion order, relying on the order of the - * output array is not guaranteed and should be avoided. - * - * ```kotlin - * // Get the entries of the 'metadata' map field. - * mapEntries("metadata") - * ``` - * - * @param mapField The map field to get the entries of. - * @return A new [Expression] representing the entries of the map. - */ - -public com.google.firebase.firestore.pipeline.Expression mapEntries(java.lang.String mapField) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the Cosine distance between two vector expressions. - * - * ```kotlin - * // Calculate the cosine distance between the 'userVector' field and the 'itemVector' field - * cosineDistance(field("userVector"), field("itemVector")) - * ``` - * - * @param vector1 The first vector (represented as an Expression) to compare against. - * @param vector2 The other vector (represented as an Expression) to compare against. - * @return A new [Expression] representing the cosine distance between the two vectors. - */ - -public com.google.firebase.firestore.pipeline.Expression cosineDistance(com.google.firebase.firestore.pipeline.Expression vector1, com.google.firebase.firestore.pipeline.Expression vector2) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the Cosine distance between vector expression and a vector literal. - * - * ```kotlin - * // Calculate the Cosine distance between the 'location' field and a target location - * cosineDistance(field("location"), doubleArrayOf(37.7749, -122.4194)) - * ``` - * - * @param vector1 The first vector (represented as an Expression) to compare against. - * @param vector2 The other vector (as an array of doubles) to compare against. - * @return A new [Expression] representing the cosine distance between the two vectors. - */ - -public com.google.firebase.firestore.pipeline.Expression cosineDistance(com.google.firebase.firestore.pipeline.Expression vector1, double[] vector2) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the Cosine distance between vector expression and a vector literal. - * - * ```kotlin - * // Calculate the Cosine distance between the 'location' field and a target location - * cosineDistance(field("location"), VectorValue.from(listOf(37.7749, -122.4194))) - * ``` - * - * @param vector1 The first vector (represented as an [Expression]) to compare against. - * @param vector2 The other vector (represented as an [VectorValue]) to compare against. - * @return A new [Expression] representing the cosine distance between the two vectors. - */ - -public com.google.firebase.firestore.pipeline.Expression cosineDistance(com.google.firebase.firestore.pipeline.Expression vector1, com.google.firebase.firestore.VectorValue vector2) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the Cosine distance between a vector field and a vector expression. - * - * ```kotlin - * // Calculate the cosine distance between the 'userVector' field and the 'itemVector' field - * cosineDistance("userVector", field("itemVector")) - * ``` - * - * @param vectorFieldName The name of the field containing the first vector. - * @param vector The other vector (represented as an Expression) to compare against. - * @return A new [Expression] representing the cosine distance between the two vectors. - */ - -public com.google.firebase.firestore.pipeline.Expression cosineDistance(java.lang.String vectorFieldName, com.google.firebase.firestore.pipeline.Expression vector) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the Cosine distance between a vector field and a vector literal. - * - * ```kotlin - * // Calculate the Cosine distance between the 'location' field and a target location - * cosineDistance("location", doubleArrayOf(37.7749, -122.4194)) - * ``` - * - * @param vectorFieldName The name of the field containing the first vector. - * @param vector The other vector (as an array of doubles) to compare against. - * @return A new [Expression] representing the cosine distance between the two vectors. - */ - -public com.google.firebase.firestore.pipeline.Expression cosineDistance(java.lang.String vectorFieldName, double[] vector) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the Cosine distance between a vector field and a vector literal. - * - * ```kotlin - * // Calculate the Cosine distance between the 'location' field and a target location - * cosineDistance("location", VectorValue.from(listOf(37.7749, -122.4194))) - * ``` - * - * @param vectorFieldName The name of the field containing the first vector. - * @param vector The other vector (represented as an [VectorValue]) to compare against. - * @return A new [Expression] representing the cosine distance between the two vectors. - */ - -public com.google.firebase.firestore.pipeline.Expression cosineDistance(java.lang.String vectorFieldName, com.google.firebase.firestore.VectorValue vector) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the dot product distance between two vector expressions. - * - * ```kotlin - * // Calculate the dot product between the 'userVector' field and the 'itemVector' field - * dotProduct(field("userVector"), field("itemVector")) - * ``` - * - * @param vector1 The first vector (represented as an Expression) to compare against. - * @param vector2 The other vector (represented as an Expression) to compare against. - * @return A new [Expression] representing the dot product distance between the two vectors. - */ - -public com.google.firebase.firestore.pipeline.Expression dotProduct(com.google.firebase.firestore.pipeline.Expression vector1, com.google.firebase.firestore.pipeline.Expression vector2) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the dot product distance between vector expression and a vector literal. - * - * ```kotlin - * // Calculate the dot product between the 'vector' field and a constant vector - * dotProduct(field("vector"), doubleArrayOf(1.0, 2.0, 3.0)) - * ``` - * - * @param vector1 The first vector (represented as an Expression) to compare against. - * @param vector2 The other vector (as an array of doubles) to compare against. - * @return A new [Expression] representing the dot product distance between the two vectors. - */ - -public com.google.firebase.firestore.pipeline.Expression dotProduct(com.google.firebase.firestore.pipeline.Expression vector1, double[] vector2) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the dot product distance between vector expression and a vector literal. - * - * ```kotlin - * // Calculate the dot product between the 'vector' field and a constant vector - * dotProduct(field("vector"), VectorValue.from(listOf(1.0, 2.0, 3.0))) - * ``` - * - * @param vector1 The first vector (represented as an [Expression]) to compare against. - * @param vector2 The other vector (represented as an [VectorValue]) to compare against. - * @return A new [Expression] representing the dot product distance between the two vectors. - */ - -public com.google.firebase.firestore.pipeline.Expression dotProduct(com.google.firebase.firestore.pipeline.Expression vector1, com.google.firebase.firestore.VectorValue vector2) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the dot product distance between a vector field and a vector expression. - * - * ```kotlin - * // Calculate the dot product between the 'userVector' field and the 'itemVector' field - * dotProduct("userVector", field("itemVector")) - * ``` - * - * @param vectorFieldName The name of the field containing the first vector. - * @param vector The other vector (represented as an Expression) to compare against. - * @return A new [Expression] representing the dot product distance between the two vectors. - */ - -public com.google.firebase.firestore.pipeline.Expression dotProduct(java.lang.String vectorFieldName, com.google.firebase.firestore.pipeline.Expression vector) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the dot product distance between vector field and a vector literal. - * - * ```kotlin - * // Calculate the dot product between the 'vector' field and a constant vector - * dotProduct("vector", doubleArrayOf(1.0, 2.0, 3.0)) - * ``` - * - * @param vectorFieldName The name of the field containing the first vector. - * @param vector The other vector (as an array of doubles) to compare against. - * @return A new [Expression] representing the dot product distance between the two vectors. - */ - -public com.google.firebase.firestore.pipeline.Expression dotProduct(java.lang.String vectorFieldName, double[] vector) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the dot product distance between a vector field and a vector literal. - * - * ```kotlin - * // Calculate the dot product between the 'vector' field and a constant vector - * dotProduct("vector", VectorValue.from(listOf(1.0, 2.0, 3.0))) - * ``` - * - * @param vectorFieldName The name of the field containing the first vector. - * @param vector The other vector (represented as an [VectorValue]) to compare against. - * @return A new [Expression] representing the dot product distance between the two vectors. - */ - -public com.google.firebase.firestore.pipeline.Expression dotProduct(java.lang.String vectorFieldName, com.google.firebase.firestore.VectorValue vector) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the Euclidean distance between two vector expressions. - * - * ```kotlin - * // Calculate the Euclidean distance between the 'userVector' field and the 'itemVector' field - * euclideanDistance(field("userVector"), field("itemVector")) - * ``` - * - * @param vector1 The first vector (represented as an Expression) to compare against. - * @param vector2 The other vector (represented as an Expression) to compare against. - * @return A new [Expression] representing the Euclidean distance between the two vectors. - */ - -public com.google.firebase.firestore.pipeline.Expression euclideanDistance(com.google.firebase.firestore.pipeline.Expression vector1, com.google.firebase.firestore.pipeline.Expression vector2) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the Euclidean distance between vector expression and a vector literal. - * - * ```kotlin - * // Calculate the Euclidean distance between the 'vector' field and a constant vector - * euclideanDistance(field("vector"), doubleArrayOf(1.0, 2.0, 3.0)) - * ``` - * - * @param vector1 The first vector (represented as an Expression) to compare against. - * @param vector2 The other vector (as an array of doubles) to compare against. - * @return A new [Expression] representing the Euclidean distance between the two vectors. - */ - -public com.google.firebase.firestore.pipeline.Expression euclideanDistance(com.google.firebase.firestore.pipeline.Expression vector1, double[] vector2) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the Euclidean distance between vector expression and a vector literal. - * - * ```kotlin - * // Calculate the Euclidean distance between the 'vector' field and a constant vector - * euclideanDistance(field("vector"), VectorValue.from(listOf(1.0, 2.0, 3.0))) - * ``` - * - * @param vector1 The first vector (represented as an [Expression]) to compare against. - * @param vector2 The other vector (represented as an [VectorValue]) to compare against. - * @return A new [Expression] representing the Euclidean distance between the two vectors. - */ - -public com.google.firebase.firestore.pipeline.Expression euclideanDistance(com.google.firebase.firestore.pipeline.Expression vector1, com.google.firebase.firestore.VectorValue vector2) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the Euclidean distance between a vector field and a vector expression. - * - * ```kotlin - * // Calculate the Euclidean distance between the 'userVector' field and the 'itemVector' field - * euclideanDistance("userVector", field("itemVector")) - * ``` - * - * @param vectorFieldName The name of the field containing the first vector. - * @param vector The other vector (represented as an Expression) to compare against. - * @return A new [Expression] representing the Euclidean distance between the two vectors. - */ - -public com.google.firebase.firestore.pipeline.Expression euclideanDistance(java.lang.String vectorFieldName, com.google.firebase.firestore.pipeline.Expression vector) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the Euclidean distance between a vector field and a vector literal. - * - * ```kotlin - * // Calculate the Euclidean distance between the 'vector' field and a constant vector - * euclideanDistance("vector", doubleArrayOf(1.0, 2.0, 3.0)) - * ``` - * - * @param vectorFieldName The name of the field containing the first vector. - * @param vector The other vector (as an array of doubles) to compare against. - * @return A new [Expression] representing the Euclidean distance between the two vectors. - */ - -public com.google.firebase.firestore.pipeline.Expression euclideanDistance(java.lang.String vectorFieldName, double[] vector) { throw new RuntimeException("Stub!"); } - -/** - * Calculates the Euclidean distance between a vector field and a vector literal. - * - * ```kotlin - * // Calculate the Euclidean distance between the 'vector' field and a constant vector - * euclideanDistance("vector", VectorValue.from(listOf(1.0, 2.0, 3.0))) - * ``` - * - * @param vectorFieldName The name of the field containing the first vector. - * @param vector The other vector (represented as an [VectorValue]) to compare against. - * @return A new [Expression] representing the Euclidean distance between the two vectors. - */ - -public com.google.firebase.firestore.pipeline.Expression euclideanDistance(java.lang.String vectorFieldName, com.google.firebase.firestore.VectorValue vector) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the length (dimension) of a Firestore Vector. - * - * ```kotlin - * // Get the vector length (dimension) of the field 'embedding'. - * vectorLength(field("embedding")) - * ``` - * - * @param vectorExpression The expression representing the Firestore Vector. - * @return A new [Expression] representing the length (dimension) of the vector. - */ - -public com.google.firebase.firestore.pipeline.Expression vectorLength(com.google.firebase.firestore.pipeline.Expression vectorExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the length (dimension) of a Firestore Vector. - * - * ```kotlin - * // Get the vector length (dimension) of the field 'embedding'. - * vectorLength("embedding") - * ``` - * - * @param fieldName The name of the field containing the Firestore Vector. - * @return A new [Expression] representing the length (dimension) of the vector. - */ - -public com.google.firebase.firestore.pipeline.Expression vectorLength(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that evaluates to the current server timestamp. - * - * ```kotlin - * // Get the current server timestamp - * currentTimestamp() - * ``` - * - * @return A new [Expression] representing the current server timestamp. - */ - -public com.google.firebase.firestore.pipeline.Expression currentTimestamp() { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that interprets an expression as the number of microseconds since the - * Unix epoch (1970-01-01 00:00:00 UTC) and returns a timestamp. - * - * ```kotlin - * // Interpret the 'microseconds' field as microseconds since epoch. - * unixMicrosToTimestamp(field("microseconds")) - * ``` - * - * @param expr The expression representing the number of microseconds since epoch. - * @return A new [Expression] representing the timestamp. - */ - -public com.google.firebase.firestore.pipeline.Expression unixMicrosToTimestamp(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that interprets a field's value as the number of microseconds since the - * Unix epoch (1970-01-01 00:00:00 UTC) and returns a timestamp. - * - * ```kotlin - * // Interpret the 'microseconds' field as microseconds since epoch. - * unixMicrosToTimestamp("microseconds") - * ``` - * - * @param fieldName The name of the field containing the number of microseconds since epoch. - * @return A new [Expression] representing the timestamp. - */ - -public com.google.firebase.firestore.pipeline.Expression unixMicrosToTimestamp(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that converts a timestamp expression to the number of microseconds - * since the Unix epoch (1970-01-01 00:00:00 UTC). - * - * ```kotlin - * // Convert the 'timestamp' field to microseconds since epoch. - * timestampToUnixMicros(field("timestamp")) - * ``` - * - * @param expr The expression representing the timestamp. - * @return A new [Expression] representing the number of microseconds since epoch. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampToUnixMicros(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that converts a timestamp field to the number of microseconds since the - * Unix epoch (1970-01-01 00:00:00 UTC). - * - * ```kotlin - * // Convert the 'timestamp' field to microseconds since epoch. - * timestampToUnixMicros("timestamp") - * ``` - * - * @param fieldName The name of the field that contains the timestamp. - * @return A new [Expression] representing the number of microseconds since epoch. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampToUnixMicros(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that interprets an expression as the number of milliseconds since the - * Unix epoch (1970-01-01 00:00:00 UTC) and returns a timestamp. - * - * ```kotlin - * // Interpret the 'milliseconds' field as milliseconds since epoch. - * unixMillisToTimestamp(field("milliseconds")) - * ``` - * - * @param expr The expression representing the number of milliseconds since epoch. - * @return A new [Expression] representing the timestamp. - */ - -public com.google.firebase.firestore.pipeline.Expression unixMillisToTimestamp(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that interprets a field's value as the number of milliseconds since the - * Unix epoch (1970-01-01 00:00:00 UTC) and returns a timestamp. - * - * ```kotlin - * // Interpret the 'milliseconds' field as milliseconds since epoch. - * unixMillisToTimestamp("milliseconds") - * ``` - * - * @param fieldName The name of the field containing the number of milliseconds since epoch. - * @return A new [Expression] representing the timestamp. - */ - -public com.google.firebase.firestore.pipeline.Expression unixMillisToTimestamp(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that converts a timestamp expression to the number of milliseconds - * since the Unix epoch (1970-01-01 00:00:00 UTC). - * - * ```kotlin - * // Convert the 'timestamp' field to milliseconds since epoch. - * timestampToUnixMillis(field("timestamp")) - * ``` - * - * @param expr The expression representing the timestamp. - * @return A new [Expression] representing the number of milliseconds since epoch. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampToUnixMillis(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that converts a timestamp field to the number of milliseconds since the - * Unix epoch (1970-01-01 00:00:00 UTC). - * - * ```kotlin - * // Convert the 'timestamp' field to milliseconds since epoch. - * timestampToUnixMillis("timestamp") - * ``` - * - * @param fieldName The name of the field that contains the timestamp. - * @return A new [Expression] representing the number of milliseconds since epoch. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampToUnixMillis(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that interprets an expression as the number of seconds since the Unix - * epoch (1970-01-01 00:00:00 UTC) and returns a timestamp. - * - * ```kotlin - * // Interpret the 'seconds' field as seconds since epoch. - * unixSecondsToTimestamp(field("seconds")) - * ``` - * - * @param expr The expression representing the number of seconds since epoch. - * @return A new [Expression] representing the timestamp. - */ - -public com.google.firebase.firestore.pipeline.Expression unixSecondsToTimestamp(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that interprets a field's value as the number of seconds since the Unix - * epoch (1970-01-01 00:00:00 UTC) and returns a timestamp. - * - * ```kotlin - * // Interpret the 'seconds' field as seconds since epoch. - * unixSecondsToTimestamp("seconds") - * ``` - * - * @param fieldName The name of the field containing the number of seconds since epoch. - * @return A new [Expression] representing the timestamp. - */ - -public com.google.firebase.firestore.pipeline.Expression unixSecondsToTimestamp(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that converts a timestamp expression to the number of seconds since the - * Unix epoch (1970-01-01 00:00:00 UTC). - * - * ```kotlin - * // Convert the 'timestamp' field to seconds since epoch. - * timestampToUnixSeconds(field("timestamp")) - * ``` - * - * @param expr The expression representing the timestamp. - * @return A new [Expression] representing the number of seconds since epoch. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampToUnixSeconds(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that converts a timestamp field to the number of seconds since the Unix - * epoch (1970-01-01 00:00:00 UTC). - * - * ```kotlin - * // Convert the 'timestamp' field to seconds since epoch. - * timestampToUnixSeconds("timestamp") - * ``` - * - * @param fieldName The name of the field that contains the timestamp. - * @return A new [Expression] representing the number of seconds since epoch. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampToUnixSeconds(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that adds a specified amount of time to a timestamp. - * - * ```kotlin - * // Add some duration determined by field 'unit' and 'amount' to the 'timestamp' field. - * timestampAdd(field("timestamp"), field("unit"), field("amount")) - * ``` - * - * @param timestamp The expression representing the timestamp. - * @param unit The expression representing the unit of time to add. Valid units include - * "microsecond", "millisecond", "second", "minute", "hour" and "day". - * @param amount The expression representing the amount of time to add. - * @return A new [Expression] representing the resulting timestamp. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampAdd(com.google.firebase.firestore.pipeline.Expression timestamp, com.google.firebase.firestore.pipeline.Expression unit, com.google.firebase.firestore.pipeline.Expression amount) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that adds a specified amount of time to a timestamp. - * - * ```kotlin - * // Add 1 day to the 'timestamp' field. - * timestampAdd(field("timestamp"), "day", 1) - * ``` - * - * @param timestamp The expression representing the timestamp. - * @param unit The unit of time to add. Valid units include "microsecond", "millisecond", - * "second", "minute", "hour" and "day". - * @param amount The amount of time to add. - * @return A new [Expression] representing the resulting timestamp. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampAdd(com.google.firebase.firestore.pipeline.Expression timestamp, java.lang.String unit, long amount) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that adds a specified amount of time to a timestamp. - * - * ```kotlin - * // Add some duration determined by field 'unit' and 'amount' to the 'timestamp' field. - * timestampAdd("timestamp", field("unit"), field("amount")) - * ``` - * - * @param fieldName The name of the field that contains the timestamp. - * @param unit The expression representing the unit of time to add. Valid units include - * "microsecond", "millisecond", "second", "minute", "hour" and "day". - * @param amount The expression representing the amount of time to add. - * @return A new [Expression] representing the resulting timestamp. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampAdd(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression unit, com.google.firebase.firestore.pipeline.Expression amount) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that adds a specified amount of time to a timestamp. - * - * ```kotlin - * // Add 1 day to the 'timestamp' field. - * timestampAdd("timestamp", "day", 1) - * ``` - * - * @param fieldName The name of the field that contains the timestamp. - * @param unit The unit of time to add. Valid units include "microsecond", "millisecond", - * "second", "minute", "hour" and "day". - * @param amount The amount of time to add. - * @return A new [Expression] representing the resulting timestamp. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampAdd(java.lang.String fieldName, java.lang.String unit, long amount) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that subtracts a specified amount of time to a timestamp. - * - * ```kotlin - * // Subtract some duration determined by field 'unit' and 'amount' from the 'timestamp' field. - * timestampSubtract(field("timestamp"), field("unit"), field("amount")) - * ``` - * - * @param timestamp The expression representing the timestamp. - * @param unit The expression representing the unit of time to subtract. Valid units include - * "microsecond", "millisecond", "second", "minute", "hour" and "day". - * @param amount The expression representing the amount of time to subtract. - * @return A new [Expression] representing the resulting timestamp. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampSubtract(com.google.firebase.firestore.pipeline.Expression timestamp, com.google.firebase.firestore.pipeline.Expression unit, com.google.firebase.firestore.pipeline.Expression amount) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that subtracts a specified amount of time to a timestamp. - * - * ```kotlin - * // Subtract 1 day from the 'timestamp' field. - * timestampSubtract(field("timestamp"), "day", 1) - * ``` - * - * @param timestamp The expression representing the timestamp. - * @param unit The unit of time to subtract. Valid units include "microsecond", "millisecond", - * "second", "minute", "hour" and "day". - * @param amount The amount of time to subtract. - * @return A new [Expression] representing the resulting timestamp. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampSubtract(com.google.firebase.firestore.pipeline.Expression timestamp, java.lang.String unit, long amount) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that subtracts a specified amount of time to a timestamp. - * - * ```kotlin - * // Subtract some duration determined by field 'unit' and 'amount' from the 'timestamp' field. - * timestampSubtract("timestamp", field("unit"), field("amount")) - * ``` - * - * @param fieldName The name of the field that contains the timestamp. - * @param unit The unit of time to subtract. Valid units include "microsecond", "millisecond", - * "second", "minute", "hour" and "day". - * @param amount The amount of time to subtract. - * @return A new [Expression] representing the resulting timestamp. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampSubtract(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression unit, com.google.firebase.firestore.pipeline.Expression amount) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that subtracts a specified amount of time to a timestamp. - * - * ```kotlin - * // Subtract 1 day from the 'timestamp' field. - * timestampSubtract("timestamp", "day", 1) - * ``` - * - * @param fieldName The name of the field that contains the timestamp. - * @param unit The unit of time to subtract. Valid units include "microsecond", "millisecond", - * "second", "minute", "hour" and "day". - * @param amount The amount of time to subtract. - * @return A new [Expression] representing the resulting timestamp. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampSubtract(java.lang.String fieldName, java.lang.String unit, long amount) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates a timestamp to a specified granularity. - * - * ```kotlin - * // Truncate the 'createdAt' timestamp to the beginning of the day. - * timestampTruncate(field("createdAt"), "day") - * ``` - * - * @param timestamp The timestamp expression. - * @param granularity The granularity to truncate to. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @return A new [Expression] representing the truncated timestamp. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampTruncate(com.google.firebase.firestore.pipeline.Expression timestamp, java.lang.String granularity) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates a timestamp to a specified granularity. - * - * ```kotlin - * // Truncate the 'createdAt' timestamp to the beginning of the day. - * timestampTruncate(field("createdAt"), field("granularity")) - * ``` - * - * @param timestamp The timestamp expression. - * @param granularity The granularity expression to truncate to. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @return A new [Expression] representing the truncated timestamp. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampTruncate(com.google.firebase.firestore.pipeline.Expression timestamp, com.google.firebase.firestore.pipeline.Expression granularity) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates a timestamp to a specified granularity. - * - * ```kotlin - * // Truncate the 'createdAt' timestamp to the beginning of the day. - * timestampTruncate("createdAt", "day") - * ``` - * - * @param fieldName The name of the field containing the timestamp. - * @param granularity The granularity to truncate to. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @return A new [Expression] representing the truncated timestamp. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampTruncate(java.lang.String fieldName, java.lang.String granularity) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates a timestamp to a specified granularity. - * - * ```kotlin - * // Truncate the 'createdAt' timestamp to the beginning of the day. - * timestampTruncate("createdAt", field("granularity")) - * ``` - * - * @param fieldName The name of the field containing the timestamp. - * @param granularity The granularity expression to truncate to. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @return A new [Expression] representing the truncated timestamp. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampTruncate(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression granularity) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates a timestamp to a specified granularity in a given - * timezone. - * - * ```kotlin - * // Truncate the 'createdAt' timestamp to the beginning of the day in "America/Los_Angeles" - * // timezone. - * timestampTruncateWithTimezone(field("createdAt"), "day", "America/Los_Angeles") - * ``` - * - * @param timestamp The timestamp expression. - * @param granularity The granularity to truncate to. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone to use for truncation. Valid values are from the TZ database - * (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". - * @return A new [Expression] representing the truncated timestamp. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(com.google.firebase.firestore.pipeline.Expression timestamp, java.lang.String granularity, java.lang.String timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates a timestamp to a specified granularity in a given - * timezone. - * - * ```kotlin - * // Truncate the 'createdAt' timestamp to the beginning of the day in "America/Los_Angeles" - * // timezone. - * timestampTruncateWithTimezone(field("createdAt"), field("granularity"), "America/Los_Angeles") - * ``` - * - * @param timestamp The timestamp expression. - * @param granularity The granularity expression to truncate to. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone to use for truncation. Valid values are from the TZ database - * (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". - * @return A new [Expression] representing the truncated timestamp. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(com.google.firebase.firestore.pipeline.Expression timestamp, com.google.firebase.firestore.pipeline.Expression granularity, java.lang.String timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates a timestamp to a specified granularity in a given - * timezone. - * - * ```kotlin - * // Truncate the 'createdAt' timestamp to the beginning of the day in "America/Los_Angeles" - * // timezone. - * timestampTruncateWithTimezone("createdAt", "day", "America/Los_Angeles") - * ``` - * - * @param fieldName The name of the field containing the timestamp. - * @param granularity The granularity to truncate to. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone to use for truncation. Valid values are from the TZ database - * (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". - * @return A new [Expression] representing the truncated timestamp. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(java.lang.String fieldName, java.lang.String granularity, java.lang.String timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates a timestamp to a specified granularity in a given - * timezone. - * - * ```kotlin - * // Truncate the 'createdAt' timestamp to the beginning of the day in "America/Los_Angeles" - * // timezone. - * timestampTruncateWithTimezone("createdAt", field("granularity"), "America/Los_Angeles") - * ``` - * - * @param fieldName The name of the field containing the timestamp. - * @param granularity The granularity expression to truncate to. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone to use for truncation. Valid values are from the TZ database - * (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". - * @return A new [Expression] representing the truncated timestamp. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression granularity, java.lang.String timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates a timestamp to a specified granularity in a given - * timezone. - * - * ```kotlin - * // Truncate the 'createdAt' timestamp to the beginning of the day in timezone specified by - * // the 'tz' field. - * timestampTruncateWithTimezone(field("createdAt"), "day", field("tz")) - * ``` - * - * @param timestamp The timestamp expression. - * @param granularity The granularity to truncate to. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone expression to use for truncation. Valid values are from the TZ - * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". - * @return A new [Expression] representing the truncated timestamp. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(com.google.firebase.firestore.pipeline.Expression timestamp, java.lang.String granularity, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates a timestamp to a specified granularity in a given - * timezone. - * - * ```kotlin - * // Truncate the 'createdAt' timestamp to the beginning of the day in timezone specified by - * // the 'tz' field. - * timestampTruncateWithTimezone(field("createdAt"), field("granularity"), field("tz")) - * ``` - * - * @param timestamp The timestamp expression. - * @param granularity The granularity expression to truncate to. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone expression to use for truncation. Valid values are from the TZ - * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". - * @return A new [Expression] representing the truncated timestamp. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(com.google.firebase.firestore.pipeline.Expression timestamp, com.google.firebase.firestore.pipeline.Expression granularity, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates a timestamp to a specified granularity in a given - * timezone. - * - * ```kotlin - * // Truncate the 'createdAt' timestamp to the beginning of the day in timezone specified by - * // the 'tz' field. - * timestampTruncateWithTimezone("createdAt", "day", field("tz")) - * ``` - * - * @param fieldName The name of the field containing the timestamp. - * @param granularity The granularity to truncate to. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone expression to use for truncation. Valid values are from the TZ - * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". - * @return A new [Expression] representing the truncated timestamp. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(java.lang.String fieldName, java.lang.String granularity, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that truncates a timestamp to a specified granularity in a given - * timezone. - * - * ```kotlin - * // Truncate the 'createdAt' timestamp to the beginning of the day in timezone specified by - * // the 'tz' field. - * timestampTruncateWithTimezone("createdAt", field("granularity"), field("tz")) - * ``` - * - * @param fieldName The name of the field containing the timestamp. - * @param granularity The granularity expression to truncate to. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "day", "week", "week(monday)", "week(tuesday)", - * "week(wednesday)", "week(thursday)", "week(friday)", "week(saturday)", "week(sunday)", - * "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone expression to use for truncation. Valid values are from the TZ - * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". - * @return A new [Expression] representing the truncated timestamp. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampTruncateWithTimezone(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression granularity, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the difference between two timestamps. - * - * ```kotlin - * // Calculate the difference between the fields 'endAt' and the field 'startAt' in unit specified by - * // the 'unit' field. - * timestampDiff(field("endAt"), field("startAt"), field("unit")) - * ``` - * - * @param end The ending timestamp expression. - * @param start The starting timestamp expression. - * @param unit The unit of time for the difference. Valid values include "microsecond", - * "millisecond", "second", "minute", "hour" and "day". - * @return A new [Expression] representing the difference. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampDiff(com.google.firebase.firestore.pipeline.Expression end, com.google.firebase.firestore.pipeline.Expression start, com.google.firebase.firestore.pipeline.Expression unit) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the difference between two timestamps. - * - * ```kotlin - * // Calculate the difference in days between 'endAt' field and 'startAt' field. - * timestampDiff(field("endAt"), field("startAt"), "day") - * ``` - * - * @param end The ending timestamp expression. - * @param start The starting timestamp expression. - * @param unit The unit of time for the difference. Valid values include "microsecond", - * "millisecond", "second", "minute", "hour" and "day". - * @return A new [Expression] representing the difference. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampDiff(com.google.firebase.firestore.pipeline.Expression end, com.google.firebase.firestore.pipeline.Expression start, java.lang.String unit) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the difference between two timestamps. - * - * ```kotlin - * // Calculate the difference in days between 'endAt' and 'startAt'. - * timestampDiff("endAt", "startAt", "day") - * ``` - * - * @param endFieldName The ending timestamp field name. - * @param startFieldName The starting timestamp field name. - * @param unit The unit of time for the difference. Valid values include "microsecond", - * "millisecond", "second", "minute", "hour" and "day". - * @return A new [Expression] representing the difference. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampDiff(java.lang.String endFieldName, java.lang.String startFieldName, java.lang.String unit) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the difference between two timestamps. - * - * ```kotlin - * // Calculate the difference in days between 'endAt' and 'startAt'. - * timestampDiff("endAt", field("startAt"), "day") - * ``` - * - * @param endFieldName The ending timestamp field name. - * @param start The starting timestamp expression. - * @param unit The unit of time for the difference. Valid values include "microsecond", - * "millisecond", "second", "minute", "hour" and "day". - * @return A new [Expression] representing the difference. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampDiff(java.lang.String endFieldName, com.google.firebase.firestore.pipeline.Expression start, java.lang.String unit) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the difference between two timestamps. - * - * ```kotlin - * // Calculate the difference in days between 'endAt' and 'startAt'. - * timestampDiff(field("endAt"), "startAt", "day") - * ``` - * - * @param end The ending timestamp expression. - * @param startFieldName The starting timestamp field name. - * @param unit The unit of time for the difference. Valid values include "microsecond", - * "millisecond", "second", "minute", "hour" and "day". - * @return A new [Expression] representing the difference. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampDiff(com.google.firebase.firestore.pipeline.Expression end, java.lang.String startFieldName, java.lang.String unit) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that extracts a specified part from a timestamp. - * - * ```kotlin - * // Extract the part specified by the field 'part' from 'createdAt'. - * timestampExtract(field("createdAt"), field("part")) - * ``` - * - * @param timestamp The timestamp expression. - * @param part The part to extract from the timestamp. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", - * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", - * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". - * @return A new [Expression] representing the extracted part. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampExtract(com.google.firebase.firestore.pipeline.Expression timestamp, com.google.firebase.firestore.pipeline.Expression part) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that extracts a specified part from a timestamp. - * - * ```kotlin - * // Extract the day from the timestamp returned by the expression. - * timestampExtract(field("createdAt"), "day") - * ``` - * - * @param timestamp The timestamp expression. - * @param part The part to extract from the timestamp. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", - * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", - * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". - * @return A new [Expression] representing the extracted part. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampExtract(com.google.firebase.firestore.pipeline.Expression timestamp, java.lang.String part) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that extracts a specified part from a timestamp. - * - * ```kotlin - * // Extract the part specified by the field 'part' from 'createdAt'. - * timestampExtract("createdAt", field("part")) - * ``` - * - * @param fieldName The name of the field containing the timestamp. - * @param part The part to extract from the timestamp. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", - * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", - * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". - * @return A new [Expression] representing the extracted part. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampExtract(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression part) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that extracts a specified part from a timestamp. - * - * ```kotlin - * // Extract the day from the timestamp in the 'createdAt' field. - * timestampExtract("createdAt", "day") - * ``` - * - * @param fieldName The name of the field containing the timestamp. - * @param part The part to extract from the timestamp. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", - * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", - * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". - * @return A new [Expression] representing the extracted part. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampExtract(java.lang.String fieldName, java.lang.String part) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that extracts a specified part from a timestamp in a given timezone. - * - * ```kotlin - * // Extract the part specified by the field 'part' from 'createdAt' in the timezone specified by - * // the field 'tz'. - * timestampExtractWithTimezone(field("createdAt"), field("part"), field("tz")) - * ``` - * - * @param timestamp The timestamp expression. - * @param part The part to extract from the timestamp. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", - * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", - * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone expression to use for extraction.Valid values are from the TZ - * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not - * specified. - * @return A new [Expression] representing the extracted part. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(com.google.firebase.firestore.pipeline.Expression timestamp, com.google.firebase.firestore.pipeline.Expression part, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that extracts a specified part from a timestamp in a given timezone. - * - * ```kotlin - * // Extract the part specified by the field 'part' from 'createdAt' in the timezone "America/Los_Angeles". - * timestampExtractWithTimezone(field("createdAt"), field("part"), "America/Los_Angeles") - * ``` - * - * @param timestamp The timestamp expression. - * @param part The part to extract from the timestamp. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", - * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", - * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone expression to use for extraction.Valid values are from the TZ - * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not - * specified. - * @return A new [Expression] representing the extracted part. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(com.google.firebase.firestore.pipeline.Expression timestamp, com.google.firebase.firestore.pipeline.Expression part, java.lang.String timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that extracts a specified part from a timestamp in a given timezone. - * - * ```kotlin - * // Extract the day from the timestamp in the 'createdAt' field in the timezone "America/Los_Angeles". - * timestampExtractWithTimezone(field("createdAt"), "day", "America/Los_Angeles") - * ``` - * - * @param timestamp The timestamp expression. - * @param part The part to extract from the timestamp. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", - * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", - * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone expression to use for extraction.Valid values are from the TZ - * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not - * specified. - * @return A new [Expression] representing the extracted part. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(com.google.firebase.firestore.pipeline.Expression timestamp, java.lang.String part, java.lang.String timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that extracts a specified part from a timestamp in a given timezone. - * - * ```kotlin - * // Extract the part specified by the field 'part' from 'createdAt' in the timezone "America/Los_Angeles". - * timestampExtractWithTimezone("createdAt", field("part"), "America/Los_Angeles") - * ``` - * - * @param fieldName The name of the field containing the timestamp. - * @param part The part to extract from the timestamp. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", - * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", - * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone expression to use for extraction.Valid values are from the TZ - * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not - * specified. - * @return A new [Expression] representing the extracted part. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression part, java.lang.String timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that extracts a specified part from a timestamp in a given timezone. - * - * ```kotlin - * // Extract the day from the timestamp in the 'createdAt' field in the timezone "America/Los_Angeles". - * timestampExtractWithTimezone("createdAt", "day", "America/Los_Angeles") - * ``` - * - * @param fieldName The name of the field containing the timestamp. - * @param part The part to extract from the timestamp. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", - * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", - * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone expression to use for extraction.Valid values are from the TZ - * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not - * specified. - * @return A new [Expression] representing the extracted part. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(java.lang.String fieldName, java.lang.String part, java.lang.String timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that extracts a specified part from a timestamp in a given timezone. - * - * ```kotlin - * // Extract the day from the timestamp in the 'createdAt' field in the timezone specified by the 'tz' field. - * timestampExtractWithTimezone(field("createdAt"), "day", field("tz")) - * ``` - * - * @param timestamp The timestamp expression. - * @param part The part to extract from the timestamp. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", - * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", - * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone expression to use for extraction.Valid values are from the TZ - * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not - * specified. - * @return A new [Expression] representing the extracted part. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(com.google.firebase.firestore.pipeline.Expression timestamp, java.lang.String part, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that extracts a specified part from a timestamp in a given timezone. - * - * ```kotlin - * // Extract the part specified by the field 'part' from 'createdAt' in the timezone specified by the 'tz' field. - * timestampExtractWithTimezone("createdAt", field("part"), field("tz")) - * ``` - * - * @param fieldName The name of the field containing the timestamp. - * @param part The part to extract from the timestamp. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", - * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", - * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone expression to use for extraction.Valid values are from the TZ - * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not - * specified. - * @return A new [Expression] representing the extracted part. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression part, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that extracts a specified part from a timestamp in a given timezone. - * - * ```kotlin - * // Extract the day from the timestamp in the 'createdAt' field in the timezone specified by the 'tz' field. - * timestampExtractWithTimezone("createdAt", "day", field("tz")) - * ``` - * - * @param fieldName The name of the field containing the timestamp. - * @param part The part to extract from the timestamp. Valid values are "microsecond", - * "millisecond", "second", "minute", "hour", "dayofweek", "day", "dayofyear", "week", - * "week(monday)", "week(tuesday)", "week(wednesday)", "week(thursday)", "week(friday)", - * "week(saturday)", "week(sunday)", "isoweek", "month", "quarter", "year", and "isoyear". - * @param timezone The timezone expression to use for extraction.Valid values are from the TZ - * database (e.g., "America/Los_Angeles") or in the format "Etc/GMT-1". Defaults to "UTC" if not - * specified. - * @return A new [Expression] representing the extracted part. - */ - -public com.google.firebase.firestore.pipeline.Expression timestampExtractWithTimezone(java.lang.String fieldName, java.lang.String part, com.google.firebase.firestore.pipeline.Expression timezone) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if two expressions are equal. - * - * ```kotlin - * // Check if the 'age' field is equal to an expression - * equal(field("age"), field("minAge").add(10)) - * ``` - * - * @param left The first expression to compare. - * @param right The second expression to compare to. - * @return A new [BooleanExpression] representing the equality comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression equal(com.google.firebase.firestore.pipeline.Expression left, com.google.firebase.firestore.pipeline.Expression right) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if an expression is equal to a value. - * - * ```kotlin - * // Check if the 'age' field is equal to 21 - * equal(field("age"), 21) - * ``` - * - * @param left The first expression to compare. - * @param right The value to compare to. - * @return A new [BooleanExpression] representing the equality comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression equal(com.google.firebase.firestore.pipeline.Expression left, java.lang.Object right) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field's value is equal to an expression. - * - * ```kotlin - * // Check if the 'age' field is equal to the 'limit' field - * equal("age", field("limit")) - * ``` - * - * @param fieldName The field name to compare. - * @param expression The expression to compare to. - * @return A new [BooleanExpression] representing the equality comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression equal(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field's value is equal to another value. - * - * ```kotlin - * // Check if the 'city' field is equal to string constant "London" - * equal("city", "London") - * ``` - * - * @param fieldName The field name to compare. - * @param value The value to compare to. - * @return A new [BooleanExpression] representing the equality comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression equal(java.lang.String fieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if two expressions are not equal. - * - * ```kotlin - * // Check if the 'status' field is not equal to the value of the 'otherStatus' field - * notEqual(field("status"), field("otherStatus")) - * ``` - * - * @param left The first expression to compare. - * @param right The second expression to compare to. - * @return A new [BooleanExpression] representing the inequality comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression notEqual(com.google.firebase.firestore.pipeline.Expression left, com.google.firebase.firestore.pipeline.Expression right) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if an expression is not equal to a value. - * - * ```kotlin - * // Check if the 'status' field is not equal to "completed" - * notEqual(field("status"), "completed") - * ``` - * - * @param left The first expression to compare. - * @param right The value to compare to. - * @return A new [BooleanExpression] representing the inequality comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression notEqual(com.google.firebase.firestore.pipeline.Expression left, java.lang.Object right) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field's value is not equal to an expression. - * - * ```kotlin - * // Check if the 'status' field is not equal to the value of the 'otherStatus' field - * notEqual("status", field("otherStatus")) - * ``` - * - * @param fieldName The field name to compare. - * @param expression The expression to compare to. - * @return A new [BooleanExpression] representing the inequality comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression notEqual(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field's value is not equal to another value. - * - * ```kotlin - * // Check if the 'status' field is not equal to "completed" - * notEqual("status", "completed") - * - * // Check if the 'country' field is not equal to "USA" - * notEqual("country", "USA") - * ``` - * - * @param fieldName The field name to compare. - * @param value The value to compare to. - * @return A new [BooleanExpression] representing the inequality comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression notEqual(java.lang.String fieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if the first expression is greater than the second - * expression. - * - * ```kotlin - * // Check if the 'age' field is greater than the 'limit' field - * greaterThan(field("age"), field("limit")) - * ``` - * - * @param left The first expression to compare. - * @param right The second expression to compare to. - * @return A new [BooleanExpression] representing the greater than comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression greaterThan(com.google.firebase.firestore.pipeline.Expression left, com.google.firebase.firestore.pipeline.Expression right) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if an expression is greater than a value. - * - * ```kotlin - * // Check if the 'price' field is greater than 100 - * greaterThan(field("price"), 100) - * ``` - * - * @param left The first expression to compare. - * @param right The value to compare to. - * @return A new [BooleanExpression] representing the greater than comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression greaterThan(com.google.firebase.firestore.pipeline.Expression left, java.lang.Object right) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field's value is greater than an expression. - * - * ```kotlin - * // Check if the 'age' field is greater than the 'limit' field - * greaterThan("age", field("limit")) - * ``` - * - * @param fieldName The field name to compare. - * @param expression The expression to compare to. - * @return A new [BooleanExpression] representing the greater than comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression greaterThan(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field's value is greater than another value. - * - * ```kotlin - * // Check if the 'price' field is greater than 100 - * greaterThan("price", 100) - * ``` - * - * @param fieldName The field name to compare. - * @param value The value to compare to. - * @return A new [BooleanExpression] representing the greater than comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression greaterThan(java.lang.String fieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if the first expression is greater than or equal to the - * second expression. - * - * ```kotlin - * // Check if the 'quantity' field is greater than or equal to field 'requirement' plus 1 - * greaterThanOrEqual(field("quantity"), field("requirement").add(1)) - * ``` - * - * @param left The first expression to compare. - * @param right The second expression to compare to. - * @return A new [BooleanExpression] representing the greater than or equal to comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression greaterThanOrEqual(com.google.firebase.firestore.pipeline.Expression left, com.google.firebase.firestore.pipeline.Expression right) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if an expression is greater than or equal to a value. - * - * ```kotlin - * // Check if the 'score' field is greater than or equal to 80 - * greaterThanOrEqual(field("score"), 80) - * ``` - * - * @param left The first expression to compare. - * @param right The value to compare to. - * @return A new [BooleanExpression] representing the greater than or equal to comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression greaterThanOrEqual(com.google.firebase.firestore.pipeline.Expression left, java.lang.Object right) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field's value is greater than or equal to an - * expression. - * - * ```kotlin - * // Check if the 'quantity' field is greater than or equal to field 'requirement' plus 1 - * greaterThanOrEqual("quantity", field("requirement").add(1)) - * ``` - * - * @param fieldName The field name to compare. - * @param expression The expression to compare to. - * @return A new [BooleanExpression] representing the greater than or equal to comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression greaterThanOrEqual(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field's value is greater than or equal to another - * value. - * - * ```kotlin - * // Check if the 'score' field is greater than or equal to 80 - * greaterThanOrEqual("score", 80) - * ``` - * - * @param fieldName The field name to compare. - * @param value The value to compare to. - * @return A new [BooleanExpression] representing the greater than or equal to comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression greaterThanOrEqual(java.lang.String fieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if the first expression is less than the second expression. - * - * ```kotlin - * // Check if the 'age' field is less than 'limit' - * lessThan(field("age"), field("limit")) - * ``` - * - * @param left The first expression to compare. - * @param right The second expression to compare to. - * @return A new [BooleanExpression] representing the less than comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression lessThan(com.google.firebase.firestore.pipeline.Expression left, com.google.firebase.firestore.pipeline.Expression right) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if an expression is less than a value. - * - * ```kotlin - * // Check if the 'price' field is less than 50 - * lessThan(field("price"), 50) - * ``` - * - * @param left The first expression to compare. - * @param right The value to compare to. - * @return A new [BooleanExpression] representing the less than comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression lessThan(com.google.firebase.firestore.pipeline.Expression left, java.lang.Object right) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field's value is less than an expression. - * - * ```kotlin - * // Check if the 'age' field is less than 'limit' - * lessThan("age", field("limit")) - * ``` - * - * @param fieldName The field name to compare. - * @param expression The expression to compare to. - * @return A new [BooleanExpression] representing the less than comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression lessThan(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field's value is less than another value. - * - * ```kotlin - * // Check if the 'price' field is less than 50 - * lessThan("price", 50) - * ``` - * - * @param fieldName The field name to compare. - * @param value The value to compare to. - * @return A new [BooleanExpression] representing the less than comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression lessThan(java.lang.String fieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if the first expression is less than or equal to the second - * expression. - * - * ```kotlin - * // Check if the 'quantity' field is less than or equal to 20 - * lessThanOrEqual(field("quantity"), constant(20)) - * ``` - * - * @param left The first expression to compare. - * @param right The second expression to compare to. - * @return A new [BooleanExpression] representing the less than or equal to comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression lessThanOrEqual(com.google.firebase.firestore.pipeline.Expression left, com.google.firebase.firestore.pipeline.Expression right) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if an expression is less than or equal to a value. - * - * ```kotlin - * // Check if the 'score' field is less than or equal to 70 - * lessThanOrEqual(field("score"), 70) - * ``` - * - * @param left The first expression to compare. - * @param right The value to compare to. - * @return A new [BooleanExpression] representing the less than or equal to comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression lessThanOrEqual(com.google.firebase.firestore.pipeline.Expression left, java.lang.Object right) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field's value is less than or equal to an expression. - * - * ```kotlin - * // Check if the 'quantity' field is less than or equal to 20 - * lessThanOrEqual("quantity", constant(20)) - * ``` - * - * @param fieldName The field name to compare. - * @param expression The expression to compare to. - * @return A new [BooleanExpression] representing the less than or equal to comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression lessThanOrEqual(java.lang.String fieldName, com.google.firebase.firestore.pipeline.Expression expression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field's value is less than or equal to another value. - * - * ```kotlin - * // Check if the 'score' field is less than or equal to 70 - * lessThanOrEqual("score", 70) - * ``` - * - * @param fieldName The field name to compare. - * @param value The value to compare to. - * @return A new [BooleanExpression] representing the less than or equal to comparison. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression lessThanOrEqual(java.lang.String fieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that concatenates strings, arrays, or blobs. Types cannot be mixed. - * - * ```kotlin - * // Concatenate the 'firstName' and 'lastName' fields with a space in between. - * concat(field("firstName"), " ", field("lastName")) - * ``` - * - * @param first The first expression to concatenate. - * @param second The second expression to concatenate. - * @param others Additional expressions to concatenate. - * @return A new [Expression] representing the concatenation. - */ - -public com.google.firebase.firestore.pipeline.Expression concat(com.google.firebase.firestore.pipeline.Expression first, com.google.firebase.firestore.pipeline.Expression second, java.lang.Object... others) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that concatenates strings, arrays, or blobs. Types cannot be mixed. - * - * ```kotlin - * // Concatenate a field with a literal string. - * concat(field("firstName"), "Doe") - * ``` - * - * @param first The first expression to concatenate. - * @param second The second value to concatenate. - * @param others Additional values to concatenate. - * @return A new [Expression] representing the concatenation. - */ - -public com.google.firebase.firestore.pipeline.Expression concat(com.google.firebase.firestore.pipeline.Expression first, java.lang.Object second, java.lang.Object... others) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that concatenates strings, arrays, or blobs. Types cannot be mixed. - * - * ```kotlin - * // Concatenate a field name with an expression. - * concat("firstName", field("lastName")) - * ``` - * - * @param first The name of the field containing the first value to concatenate. - * @param second The second expression to concatenate. - * @param others Additional expressions to concatenate. - * @return A new [Expression] representing the concatenation. - */ - -public com.google.firebase.firestore.pipeline.Expression concat(java.lang.String first, com.google.firebase.firestore.pipeline.Expression second, java.lang.Object... others) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that concatenates strings, arrays, or blobs. Types cannot be mixed. - * - * ```kotlin - * // Concatenate a field name with a literal string. - * concat("firstName", "Doe") - * ``` - * - * @param first The name of the field containing the first value to concatenate. - * @param second The second value to concatenate. - * @param others Additional values to concatenate. - * @return A new [Expression] representing the concatenation. - */ - -public com.google.firebase.firestore.pipeline.Expression concat(java.lang.String first, java.lang.Object second, java.lang.Object... others) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that creates a Firestore array value from an input array. - * - * ```kotlin - * // Create an array of numbers - * array(1, 2, 3) - * - * // Create an array containing a field value and a constant - * array(field("quantity"), 10) - * ``` - * - * @param elements The input array to evaluate in the expression. - * @return A new [Expression] representing the array function. - */ - -public com.google.firebase.firestore.pipeline.Expression array(java.lang.Object... elements) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that creates a Firestore array value from an input array. - * - * @param elements The input array to evaluate in the expression. - * @return A new [Expression] representing the array function. - */ - -public com.google.firebase.firestore.pipeline.Expression array(java.util.List elements) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that concatenates an array with other arrays. - * - * ```kotlin - * // Combine the 'items' array with another array field. - * arrayConcat(field("items"), field("otherItems")) - * ``` - * - * @param firstArray The first array expression to concatenate to. - * @param secondArray An expression that evaluates to array to concatenate. - * @param otherArrays Optional additional array expressions or array literals to concatenate. - * @return A new [Expression] representing the arrayConcat operation. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayConcat(com.google.firebase.firestore.pipeline.Expression firstArray, com.google.firebase.firestore.pipeline.Expression secondArray, java.lang.Object... otherArrays) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that concatenates an array with other arrays. - * - * ```kotlin - * // Combine the 'items' array with another array field. - * arrayConcat(field("items"), field("otherItems")) - * ``` - * - * @param firstArray The first array expression to concatenate to. - * @param secondArray An array expression or array literal to concatenate. - * @param otherArrays Optional additional array expressions or array literals to concatenate. - * @return A new [Expression] representing the arrayConcat operation. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayConcat(com.google.firebase.firestore.pipeline.Expression firstArray, java.lang.Object secondArray, java.lang.Object... otherArrays) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that concatenates a field's array value with other arrays. - * - * ```kotlin - * // Combine the 'items' array with another array field. - * arrayConcat("items", field("otherItems")) - * ``` - * - * @param firstArrayField The name of field that contains first array to concatenate to. - * @param secondArray An expression that evaluates to array to concatenate. - * @param otherArrays Optional additional array expressions or array literals to concatenate. - * @return A new [Expression] representing the arrayConcat operation. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayConcat(java.lang.String firstArrayField, com.google.firebase.firestore.pipeline.Expression secondArray, java.lang.Object... otherArrays) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that concatenates a field's array value with other arrays. - * - * ```kotlin - * // Combine the 'items' array with a literal array. - * arrayConcat("items", listOf("a", "b")) - * ``` - * - * @param firstArrayField The name of field that contains first array to concatenate to. - * @param secondArray An array expression or array literal to concatenate. - * @param otherArrays Optional additional array expressions or array literals to concatenate. - * @return A new [Expression] representing the arrayConcat operation. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayConcat(java.lang.String firstArrayField, java.lang.Object secondArray, java.lang.Object... otherArrays) { throw new RuntimeException("Stub!"); } - -/** - * Reverses the order of elements in the [array]. - * - * ```kotlin - * // Reverse the value of the 'myArray' field. - * arrayReverse(field("myArray")) - * ``` - * - * @param array The array expression to reverse. - * @return A new [Expression] representing the arrayReverse operation. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayReverse(com.google.firebase.firestore.pipeline.Expression array) { throw new RuntimeException("Stub!"); } - -/** - * Reverses the order of elements in the array field. - * - * ```kotlin - * // Reverse the value of the 'myArray' field. - * arrayReverse("myArray") - * ``` - * - * @param arrayFieldName The name of field that contains the array to reverse. - * @return A new [Expression] representing the arrayReverse operation. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayReverse(java.lang.String arrayFieldName) { throw new RuntimeException("Stub!"); } - -/** - * Filters an [array] expression based on a predicate. - * - * ```kotlin - * // Filter 'scores' array to include only values greater than 50 - * arrayFilter(field("scores"), "score", greaterThan(variable("score"), 50)) - * ``` - * - * @param array The array expression to filter. - * @param alias The alias to use for the current element in the filter expression. - * @param filter The predicate boolean expression used to filter the elements. - * @return A new [Expression] representing the arrayFilter operation. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayFilter(com.google.firebase.firestore.pipeline.Expression array, java.lang.String alias, com.google.firebase.firestore.pipeline.BooleanExpression filter) { throw new RuntimeException("Stub!"); } - -/** - * Filters an array field based on a predicate. - * - * ```kotlin - * // Filter 'scores' array to include only values greater than 50 - * arrayFilter("scores", "score", greaterThan(variable("score"), 50)) - * ``` - * - * @param arrayFieldName The name of field that contains array to filter. - * @param alias The alias to use for the current element in the filter expression. - * @param filter The predicate boolean expression used to filter the elements. - * @return A new [Expression] representing the arrayFilter operation. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayFilter(java.lang.String arrayFieldName, java.lang.String alias, com.google.firebase.firestore.pipeline.BooleanExpression filter) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a provided transformation to each element in an array. - * - * ```kotlin - * // Transform 'scores' array by multiplying each score by 10 - * arrayTransform(field("scores"), "score", multiply(variable("score"), 10)) - * ``` - * - * @param array The array expression to transform. - * @param elementAlias The alias to use for the current element in the transform expression. - * @param transform The expression used to transform the elements. - * @return A new [Expression] representing the arrayTransform operation. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayTransform(com.google.firebase.firestore.pipeline.Expression array, java.lang.String elementAlias, com.google.firebase.firestore.pipeline.Expression transform) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a provided transformation to each element in an array. - * - * ```kotlin - * // Transform 'scores' array by multiplying each score by 10 - * arrayTransform("scores", "score", multiply(variable("score"), 10)) - * ``` - * - * @param arrayFieldName The name of field that contains array to transform. - * @param elementAlias The alias to use for the current element in the transform expression. - * @param transform The expression used to transform the elements. - * @return A new [Expression] representing the arrayTransform operation. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayTransform(java.lang.String arrayFieldName, java.lang.String elementAlias, com.google.firebase.firestore.pipeline.Expression transform) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a provided transformation to each element in an array, - * providing the element's index to the transformation expression. - * - * ```kotlin - * // Transform 'scores' array by adding the index - * arrayTransformWithIndex(field("scores"), "score", "i", add(variable("score"), variable("i"))) - * ``` - * - * @param array The array expression to transform. - * @param elementAlias The alias to use for the current element in the transform expression. - * @param indexAlias The alias to use for the current index. - * @param transform The expression used to transform the elements. - * @return A new [Expression] representing the arrayTransformWithIndex operation. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayTransformWithIndex(com.google.firebase.firestore.pipeline.Expression array, java.lang.String elementAlias, java.lang.String indexAlias, com.google.firebase.firestore.pipeline.Expression transform) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that applies a provided transformation to each element in an array, - * providing the element's index to the transformation expression. - * - * ```kotlin - * // Transform 'scores' array by adding the index - * arrayTransformWithIndex("scores", "score", "i", add(variable("score"), variable("i"))) - * ``` - * - * @param arrayFieldName The name of field that contains array to transform. - * @param elementAlias The alias to use for the current element in the transform expression. - * @param indexAlias The alias to use for the current index. - * @param transform The expression used to transform the elements. - * @return A new [Expression] representing the arrayTransformWithIndex operation. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayTransformWithIndex(java.lang.String arrayFieldName, java.lang.String elementAlias, java.lang.String indexAlias, com.google.firebase.firestore.pipeline.Expression transform) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a slice of an [array] expression to its end. - * - * ```kotlin - * // Get elements from the 'items' array starting from index 2 - * arraySliceToEnd(field("items"), 2) - * ``` - * - * @param array The array expression. - * @param offset The starting index. - * @return A new [Expression] representing the arraySliceToEnd operation. - */ - -public com.google.firebase.firestore.pipeline.Expression arraySliceToEnd(com.google.firebase.firestore.pipeline.Expression array, int offset) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a slice of an [array] expression to its end. - * - * ```kotlin - * // Get elements from the 'items' array starting at an offset defined by a field - * arraySliceToEnd(field("items"), field("startIdx")) - * ``` - * - * @param array The array expression. - * @param offset The starting index. - * @return A new [Expression] representing the arraySliceToEnd operation. - */ - -public com.google.firebase.firestore.pipeline.Expression arraySliceToEnd(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression offset) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a slice of an array field to its end. - * - * ```kotlin - * // Get elements from the 'items' array starting from index 2 - * arraySliceToEnd("items", 2) - * ``` - * - * @param arrayFieldName The name of field that contains the array. - * @param offset The starting index. - * @return A new [Expression] representing the arraySliceToEnd operation. - */ - -public com.google.firebase.firestore.pipeline.Expression arraySliceToEnd(java.lang.String arrayFieldName, int offset) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a slice of an array field to its end. - * - * ```kotlin - * // Get elements from the 'items' array starting at an offset defined by a field - * arraySliceToEnd("items", field("startIdx")) - * ``` - * - * @param arrayFieldName The name of field that contains the array. - * @param offset The starting index. - * @return A new [Expression] representing the arraySliceToEnd operation. - */ - -public com.google.firebase.firestore.pipeline.Expression arraySliceToEnd(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression offset) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a slice of an [array] expression. - * - * ```kotlin - * // Get 5 elements from the 'items' array starting from index 2 - * arraySlice(field("items"), 2, 5) - * ``` - * - * @param array The array expression. - * @param offset The starting index. - * @param length The number of elements to return. - * @return A new [Expression] representing the arraySlice operation. - */ - -public com.google.firebase.firestore.pipeline.Expression arraySlice(com.google.firebase.firestore.pipeline.Expression array, int offset, int length) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a slice of an array field. - * - * ```kotlin - * // Get 5 elements from the 'items' array starting from index 2 - * arraySlice("items", 2, 5) - * ``` - * - * @param arrayFieldName The name of field that contains the array. - * @param offset The starting index. - * @param length The number of elements to return. - * @return A new [Expression] representing the arraySlice operation. - */ - -public com.google.firebase.firestore.pipeline.Expression arraySlice(java.lang.String arrayFieldName, int offset, int length) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a slice of an [array] expression. - * - * ```kotlin - * // Get elements from the 'items' array using expressions for offset and length - * arraySlice(field("items"), field("startIdx"), field("length")) - * ``` - * - * @param array The array expression. - * @param offset The starting index. - * @param length The number of elements to return. - * @return A new [Expression] representing the arraySlice operation. - */ - -public com.google.firebase.firestore.pipeline.Expression arraySlice(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression offset, com.google.firebase.firestore.pipeline.Expression length) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a slice of an array field. - * - * ```kotlin - * // Get elements from the 'items' array using expressions for offset and length - * arraySlice("items", field("startIdx"), field("length")) - * ``` - * - * @param arrayFieldName The name of field that contains the array. - * @param offset The starting index. - * @param length The number of elements to return. - * @return A new [Expression] representing the arraySlice operation. - */ - -public com.google.firebase.firestore.pipeline.Expression arraySlice(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression offset, com.google.firebase.firestore.pipeline.Expression length) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the sum of the elements in an array. - * - * ```kotlin - * // Get the sum of elements in the 'scores' array. - * arraySum(field("scores")) - * ``` - * - * @param array The array expression to sum. - * @return A new [Expression] representing the sum of the array elements. - */ - -public com.google.firebase.firestore.pipeline.Expression arraySum(com.google.firebase.firestore.pipeline.Expression array) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the sum of the elements in an array field. - * - * ```kotlin - * // Get the sum of elements in the 'scores' array. - * arraySum("scores") - * ``` - * - * @param arrayFieldName The name of the field containing the array to sum. - * @return A new [Expression] representing the sum of the array elements. - */ - -public com.google.firebase.firestore.pipeline.Expression arraySum(java.lang.String arrayFieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if the array contains a specific [element]. - * - * @param array The array expression to check. - * @param element The element to search for in the array. - * @return A new [BooleanExpression] representing the arrayContains operation. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression arrayContains(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression element) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if the array field contains a specific [element]. - * - * ```kotlin - * // Check if the 'sizes' array contains the value from the 'selectedSize' field - * arrayContains("sizes", field("selectedSize")) - * ``` - * - * @param arrayFieldName The name of field that contains array to check. - * @param element The element to search for in the array. - * @return A new [BooleanExpression] representing the arrayContains operation. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression arrayContains(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression element) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if the [array] contains a specific [element]. - * - * ```kotlin - * // Check if the 'sizes' array contains the value from the 'selectedSize' field - * arrayContains(field("sizes"), field("selectedSize")) - * - * // Check if the 'colors' array contains "red" - * arrayContains(field("colors"), "red") - * ``` - * - * @param array The array expression to check. - * @param element The element to search for in the array. - * @return A new [BooleanExpression] representing the arrayContains operation. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression arrayContains(com.google.firebase.firestore.pipeline.Expression array, java.lang.Object element) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if the array field contains a specific [element]. - * - * ```kotlin - * // Check if the 'colors' array contains "red" - * arrayContains("colors", "red") - * ``` - * - * @param arrayFieldName The name of field that contains array to check. - * @param element The element to search for in the array. - * @return A new [BooleanExpression] representing the arrayContains operation. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression arrayContains(java.lang.String arrayFieldName, java.lang.Object element) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if [array] contains all the specified [values]. - * - * ```kotlin - * // Check if the 'tags' array contains both the value in field "tag1" and the literal value "tag2" - * arrayContainsAll(field("tags"), listOf(field("tag1"), "tag2")) - * ``` - * - * @param array The array expression to check. - * @param values The elements to check for in the array. - * @return A new [BooleanExpression] representing the arrayContainsAll operation. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAll(com.google.firebase.firestore.pipeline.Expression array, java.util.List values) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if [array] contains all elements of [arrayExpression]. - * - * ```kotlin - * // Check if the 'tags' array contains both of the values from field "tag1" and the literal value "tag2" - * arrayContainsAll(field("tags"), array(field("tag1"), "tag2")) - * ``` - * - * @param array The array expression to check. - * @param arrayExpression The elements to check for in the array. - * @return A new [BooleanExpression] representing the arrayContainsAll operation. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAll(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if array field contains all the specified [values]. - * - * ```kotlin - * // Check if the 'tags' array contains both "internal" and "public" - * arrayContainsAll("tags", listOf("internal", "public")) - * ``` - * - * @param arrayFieldName The name of field that contains array to check. - * @param values The elements to check for in the array. - * @return A new [BooleanExpression] representing the arrayContainsAll operation. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAll(java.lang.String arrayFieldName, java.util.List values) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if array field contains all elements of [arrayExpression]. - * - * ```kotlin - * // Check if the 'permissions' array contains all the required permissions - * arrayContainsAll("permissions", field("requiredPermissions")) - * ``` - * - * @param arrayFieldName The name of field that contains array to check. - * @param arrayExpression The elements to check for in the array. - * @return A new [BooleanExpression] representing the arrayContainsAll operation. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAll(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if [array] contains any of the specified [values]. - * - * ```kotlin - * // Check if the 'categories' array contains either values from field "cate1" or "cate2" - * arrayContainsAny(field("categories"), listOf(field("cate1"), field("cate2"))) - * ``` - * - * @param array The array expression to check. - * @param values The elements to check for in the array. - * @return A new [BooleanExpression] representing the arrayContainsAny operation. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAny(com.google.firebase.firestore.pipeline.Expression array, java.util.List values) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if [array] contains any elements of [arrayExpression]. - * - * ```kotlin - * // Check if the 'groups' array contains either the value from the 'userGroup' field - * // or the value "guest" - * arrayContainsAny(field("groups"), array(field("userGroup"), "guest")) - * ``` - * - * @param array The array expression to check. - * @param arrayExpression The elements to check for in the array. - * @return A new [BooleanExpression] representing the arrayContainsAny operation. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAny(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if array field contains any of the specified [values]. - * - * ```kotlin - * // Check if the 'roles' array contains "admin" or "editor" - * arrayContainsAny("roles", listOf("admin", "editor")) - * ``` - * - * @param arrayFieldName The name of field that contains array to check. - * @param values The elements to check for in the array. - * @return A new [BooleanExpression] representing the arrayContainsAny operation. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAny(java.lang.String arrayFieldName, java.util.List values) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if array field contains any elements of [arrayExpression]. - * - * ```kotlin - * // Check if the 'userGroups' array contains any of the 'targetGroups' - * arrayContainsAny("userGroups", field("targetGroups")) - * ``` - * - * @param arrayFieldName The name of field that contains array to check. - * @param arrayExpression The elements to check for in the array. - * @return A new [BooleanExpression] representing the arrayContainsAny operation. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression arrayContainsAny(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression arrayExpression) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the length of an [array] expression. - * - * ```kotlin - * // Get the number of items in the 'cart' array - * arrayLength(field("cart")) - * ``` - * - * @param array The array expression to calculate the length of. - * @return A new [Expression] representing the length of the array. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayLength(com.google.firebase.firestore.pipeline.Expression array) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that calculates the length of an array field. - * - * ```kotlin - * // Get the number of items in the 'cart' array - * arrayLength("cart") - * ``` - * - * @param arrayFieldName The name of the field containing an array to calculate the length of. - * @return A new [Expression] representing the length of the array. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayLength(java.lang.String arrayFieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first element of an [array] expression. - * - * ```kotlin - * // Get the first element of the 'myArray' field. - * arrayFirst(field("myArray")) - * ``` - * - * @param array The array expression to get the first element from. - * @return A new [Expression] representing the first element. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayFirst(com.google.firebase.firestore.pipeline.Expression array) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first element of an array field. - * - * ```kotlin - * // Get the first element of the 'myArray' field. - * arrayFirst("myArray") - * ``` - * - * @param arrayFieldName The name of the field containing an array to get the first element - * from. - * @return A new [Expression] representing the first element. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayFirst(java.lang.String arrayFieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first `n` elements of an [array] expression. - * - * ```kotlin - * // Get the first 3 elements of the 'myArray' field. - * arrayFirstN(field("myArray"), 3) - * ``` - * - * @param array The array expression. - * @param n The number of elements to return. - * @return A new [Expression] representing the first `n` elements. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayFirstN(com.google.firebase.firestore.pipeline.Expression array, int n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first `n` elements of an [array] expression. - * - * ```kotlin - * // Get the first n elements of the 'myArray' field. - * arrayFirstN(field("myArray"), field("count")) - * ``` - * - * @param array The array expression. - * @param n An expression evaluating to the number of elements to return. - * @return A new [Expression] representing the first `n` elements. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayFirstN(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first `n` elements of an array field. - * - * ```kotlin - * // Get the first n elements of the 'myArray' field. - * arrayFirstN("myArray", field("count")) - * ``` - * - * @param arrayFieldName The name of the field containing an array to get the first `n` elements - * from. - * @param n An expression evaluating to the number of elements to return. - * @return A new [Expression] representing the first `n` elements. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayFirstN(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first `n` elements of an array field. - * - * ```kotlin - * // Get the first n elements of the 'myArray' field. - * arrayFirstN("myArray", 3) - * ``` - * - * @param arrayFieldName The name of the field containing an array to get the first `n` elements - * from. - * @param n The number of elements to return. - * @return A new [Expression] representing the first `n` elements. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayFirstN(java.lang.String arrayFieldName, int n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the last element of an [array] expression. - * - * ```kotlin - * // Get the last element of the 'myArray' field. - * arrayLast(field("myArray")) - * ``` - * - * @param array The array expression to get the last element from. - * @return A new [Expression] representing the last element. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayLast(com.google.firebase.firestore.pipeline.Expression array) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the last element of an array field. - * - * ```kotlin - * // Get the last element of the 'myArray' field. - * arrayLast("myArray") - * ``` - * - * @param arrayFieldName The name of the field containing an array to get the last element from. - * @return A new [Expression] representing the last element. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayLast(java.lang.String arrayFieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the last `n` elements of an [array] expression. - * - * ```kotlin - * // Get the last 3 elements of the 'myArray' field. - * arrayLastN(field("myArray"), 3) - * ``` - * - * @param array The array expression. - * @param n The number of elements to return. - * @return A new [Expression] representing the last `n` elements. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayLastN(com.google.firebase.firestore.pipeline.Expression array, int n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the last `n` elements of an [array] expression. - * - * ```kotlin - * // Get the last n elements of the 'myArray' field. - * arrayLastN(field("myArray"), field("count")) - * ``` - * - * @param array The array expression. - * @param n An expression evaluating to the number of elements to return. - * @return A new [Expression] representing the last `n` elements. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayLastN(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the last `n` elements of an array field. - * - * ```kotlin - * // Get the last n elements of the 'myArray' field. - * arrayLastN("myArray", field("count")) - * ``` - * - * @param arrayFieldName The name of the field containing an array to get the last `n` elements - * from. - * @param n An expression evaluating to the number of elements to return. - * @return A new [Expression] representing the last `n` elements. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayLastN(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the last `n` elements of an array field. - * - * ```kotlin - * // Get the last n elements of the 'myArray' field. - * arrayLastN("myArray", 3) - * ``` - * - * @param arrayFieldName The name of the field containing an array to get the last `n` elements - * from. - * @param n The number of elements to return. - * @return A new [Expression] representing the last `n` elements. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayLastN(java.lang.String arrayFieldName, int n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the minimum element of the [array]. - * - * ```kotlin - * // Get the minimum element of the 'myArray' field. - * arrayMinimum(field("myArray")) - * ``` - * - * @param array The array expression. - * @return A new [Expression] representing the minimum element. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayMinimum(com.google.firebase.firestore.pipeline.Expression array) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the minimum element of an array field. - * - * ```kotlin - * // Get the minimum element of the 'myArray' field. - * arrayMinimum("myArray") - * ``` - * - * @param arrayFieldName The name of the field containing an array to get the minimum element - * from. - * @return A new [Expression] representing the minimum element. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayMinimum(java.lang.String arrayFieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first `n` smallest elements of the [array]. - * - * Note: Returns the n smallest non-null elements in the array, in ascending order. This does - * not use a stable sort, meaning the order of equivalent elements is undefined. - * - * ```kotlin - * // Get the 3 smallest elements of the 'myArray' field. - * arrayMinimumN(field("myArray"), 3) - * ``` - * - * @param array The array expression. - * @param n The number of elements to return. - * @return A new [Expression] representing the first `n` smallest elements. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayMinimumN(com.google.firebase.firestore.pipeline.Expression array, int n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first `n` smallest elements of the [array]. - * - * Note: Returns the n smallest non-null elements in the array, in ascending order. This does - * not use a stable sort, meaning the order of equivalent elements is undefined. - * - * ```kotlin - * // Get the n smallest elements of the 'myArray' field. - * arrayMinimumN(field("myArray"), field("count")) - * ``` - * - * @param array The array expression. - * @param n An expression evaluating to the number of elements to return. - * @return A new [Expression] representing the first `n` smallest elements. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayMinimumN(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first `n` smallest elements of the [array]. - * - * Note: Returns the n smallest non-null elements in the array, in ascending order. This does - * not use a stable sort, meaning the order of equivalent elements is undefined. - * - * ```kotlin - * // Get the n smallest elements of the 'myArray' field. - * arrayMinimumN("myArray", field("count")) - * ``` - * - * @param arrayFieldName The name of the field containing an array to get the first `n` smallest - * elements from. - * @param n An expression evaluating to the number of elements to return. - * @return A new [Expression] representing the first `n` smallest elements. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayMinimumN(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first `n` smallest elements of the [array]. - * - * Note: Returns the n smallest non-null elements in the array, in ascending order. This does - * not use a stable sort, meaning the order of equivalent elements is undefined. - * - * ```kotlin - * // Get the 3 smallest elements of the 'myArray' field. - * arrayMinimumN("myArray", 3) - * ``` - * - * @param arrayFieldName The name of the field containing an array to get the first `n` smallest - * elements from. - * @param n The number of elements to return. - * @return A new [Expression] representing the first `n` smallest elements. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayMinimumN(java.lang.String arrayFieldName, int n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the maximum element of the [array]. - * - * ```kotlin - * // Get the maximum element of the 'myArray' field. - * arrayMaximum(field("myArray")) - * ``` - * - * @param array The array expression. - * @return A new [Expression] representing the maximum element. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayMaximum(com.google.firebase.firestore.pipeline.Expression array) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the maximum element of an array field. - * - * ```kotlin - * // Get the maximum element of the 'myArray' field. - * arrayMaximum("myArray") - * ``` - * - * @param arrayFieldName The name of the field containing an array to get the maximum element - * from. - * @return A new [Expression] representing the maximum element. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayMaximum(java.lang.String arrayFieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first `n` largest elements of the [array]. - * - * Note: Returns the n largest non-null elements in the array, in descending order. This does - * not use a stable sort, meaning the order of equivalent elements is undefined. - * - * ```kotlin - * // Get the 3 largest elements of the 'myArray' field. - * arrayMaximumN(field("myArray"), 3) - * ``` - * - * @param array The array expression. - * @param n The number of elements to return. - * @return A new [Expression] representing the first `n` largest elements. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayMaximumN(com.google.firebase.firestore.pipeline.Expression array, int n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first `n` largest elements of the [array]. - * - * Note: Returns the n largest non-null elements in the array, in descending order. This does - * not use a stable sort, meaning the order of equivalent elements is undefined. - * - * ```kotlin - * // Get the n largest elements of the 'myArray' field. - * arrayMaximumN(field("myArray"), field("count")) - * ``` - * - * @param array The array expression. - * @param n An expression evaluating to the number of elements to return. - * @return A new [Expression] representing the first `n` largest elements. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayMaximumN(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first `n` largest elements of the [array]. - * - * Note: Returns the n largest non-null elements in the array, in descending order. This does - * not use a stable sort, meaning the order of equivalent elements is undefined. - * - * ```kotlin - * // Get the 3 largest elements of the 'myArray' field. - * arrayMaximumN("myArray", 3) - * ``` - * - * @param arrayFieldName The name of the field containing an array to get the first `n` largest - * elements from. - * @param n The number of elements to return. - * @return A new [Expression] representing the first `n` largest elements. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayMaximumN(java.lang.String arrayFieldName, int n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first `n` largest elements of the [array]. - * - * Note: Returns the n largest non-null elements in the array, in descending order. This does - * not use a stable sort, meaning the order of equivalent elements is undefined. - * - * ```kotlin - * // Get the n largest elements of the 'myArray' field. - * arrayMaximumN("myArray", field("count")) - * ``` - * - * @param arrayFieldName The name of the field containing an array to get the first `n` largest - * elements from. - * @param n An expression evaluating to the number of elements to return. - * @return A new [Expression] representing the first `n` largest elements. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayMaximumN(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression n) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the index of the first occurrence of the specified [value] - * in the [array], or -1 if the value is not found. - * - * ```kotlin - * // Get the index of 'foo' in the 'tags' array field. - * arrayIndexOf(field("tags"), "foo") - * ``` - * - * @param array The array expression. - * @param value The value to search for. - * @return A new [Expression] representing the index of the value. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayIndexOf(com.google.firebase.firestore.pipeline.Expression array, java.lang.Object value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the index of the first occurrence of the specified [value] - * in the [array], or -1 if the value is not found. - * - * ```kotlin - * // Get the index of 'foo' in the 'tags' array field. - * arrayIndexOf(field("tags"), "foo") - * ``` - * - * @param arrayFieldName The name of the field containing an array to get the index of the value - * from. - * @param value The value to search for. - * @return A new [Expression] representing the index of the value. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayIndexOf(java.lang.String arrayFieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the index of the last occurrence of the specified [value] - * in the [array], or -1 if the value is not found. - * - * ```kotlin - * // Get the last index of 'foo' in the 'tags' array field. - * arrayLastIndexOf(field("tags"), "foo") - * ``` - * - * @param array The array expression. - * @param value The value to search for. - * @return A new [Expression] representing the last index of the value. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayLastIndexOf(com.google.firebase.firestore.pipeline.Expression array, java.lang.Object value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the index of the last occurrence of the specified [value] - * in the [array], or -1 if the value is not found. - * - * ```kotlin - * // Get the last index of 'foo' in the 'tags' array field. - * arrayLastIndexOf(field("tags"), "foo") - * ``` - * - * @param arrayFieldName The name of the field containing an array to get the last index of the - * value from. - * @param value The value to search for. - * @return A new [Expression] representing the last index of the value. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayLastIndexOf(java.lang.String arrayFieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a list of all indices where the specified [value] occurs - * in the [array]. - * - * ```kotlin - * // Get all indices of 'foo' in the 'tags' array field. - * arrayIndexOfAll(field("tags"), "foo") - * ``` - * - * @param array The array expression. - * @param value The value to search for. - * @return A new [Expression] representing the list of indices. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayIndexOfAll(com.google.firebase.firestore.pipeline.Expression array, java.lang.Object value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns a list of all indices where the specified [value] occurs - * in the [array]. - * - * ```kotlin - * // Get all indices of 'foo' in the 'tags' array field. - * arrayIndexOfAll(field("tags"), "foo") - * ``` - * - * @param arrayFieldName The name of the field containing an array to get the indices of the - * value from. - * @param value The value to search for. - * @return A new [Expression] representing the list of indices. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayIndexOfAll(java.lang.String arrayFieldName, java.lang.Object value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that indexes into an array from the beginning or end and return the - * element. If the offset exceeds the array length, an error is returned. A negative offset, - * starts from the end. - * - * ```kotlin - * // Return the value in the tags field array at index specified by field 'favoriteTag'. - * arrayGet(field("tags"), field("favoriteTag")) - * ``` - * - * @param array An [Expression] evaluating to an array. - * @param offset An Expression evaluating to the index of the element to return. - * @return A new [Expression] representing the arrayOffset operation. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayGet(com.google.firebase.firestore.pipeline.Expression array, com.google.firebase.firestore.pipeline.Expression offset) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that indexes into an array from the beginning or end and return the - * element. If the offset exceeds the array length, an error is returned. A negative offset, - * starts from the end. - * - * ```kotlin - * // Return the value in the 'tags' field array at index `1`. - * arrayGet(field("tags"), 1) - * ``` - * - * @param array An [Expression] evaluating to an array. - * @param offset The index of the element to return. - * @return A new [Expression] representing the arrayOffset operation. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayGet(com.google.firebase.firestore.pipeline.Expression array, int offset) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that indexes into an array from the beginning or end and return the - * element. If the offset exceeds the array length, an error is returned. A negative offset, - * starts from the end. - * - * ```kotlin - * // Return the value in the tags field array at index specified by field 'favoriteTag'. - * arrayGet("tags", field("favoriteTag")) - * ``` - * - * @param arrayFieldName The name of an array field. - * @param offset An Expression evaluating to the index of the element to return. - * @return A new [Expression] representing the arrayOffset operation. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayGet(java.lang.String arrayFieldName, com.google.firebase.firestore.pipeline.Expression offset) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that indexes into an array from the beginning or end and return the - * element. If the offset exceeds the array length, an error is returned. A negative offset, - * starts from the end. - * - * ```kotlin - * // Return the value in the 'tags' field array at index `1`. - * arrayGet("tags", 1) - * ``` - * - * @param arrayFieldName The name of an array field. - * @param offset The index of the element to return. - * @return A new [Expression] representing the arrayOffset operation. - */ - -public com.google.firebase.firestore.pipeline.Expression arrayGet(java.lang.String arrayFieldName, int offset) { throw new RuntimeException("Stub!"); } - -/** - * Creates a conditional expression that evaluates to a [thenExpr] expression if a condition is - * true or an [elseExpr] expression if the condition is false. - * - * @param condition The condition to evaluate. - * @param thenExpr The expression to evaluate if the condition is true. - * @param elseExpr The expression to evaluate if the condition is false. - * @return A new [Expression] representing the conditional operation. - */ - -public com.google.firebase.firestore.pipeline.Expression conditional(com.google.firebase.firestore.pipeline.BooleanExpression condition, com.google.firebase.firestore.pipeline.Expression thenExpr, com.google.firebase.firestore.pipeline.Expression elseExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates a conditional expression that evaluates to a [thenValue] if a condition is true or an - * [elseValue] if the condition is false. - * - * ```kotlin - * // If the 'quantity' field is greater than 10, return "High", otherwise return "Low" - * conditional(field("quantity").greaterThan(10), "High", "Low") - * ``` - * - * @param condition The condition to evaluate. - * @param thenValue Value if the condition is true. - * @param elseValue Value if the condition is false. - * @return A new [Expression] representing the conditional operation. - */ - -public com.google.firebase.firestore.pipeline.Expression conditional(com.google.firebase.firestore.pipeline.BooleanExpression condition, java.lang.Object thenValue, java.lang.Object elseValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field exists. - * - * @param value An expression evaluates to the name of the field to check. - * @return A new [Expression] representing the exists check. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression exists(com.google.firebase.firestore.pipeline.Expression value) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a field exists. - * - * @param fieldName The field name to check. - * @return A new [Expression] representing the exists check. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression exists(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [catchExpr] argument if there is an error, else return - * the result of the [tryExpr] argument evaluation. - * - * ```kotlin - * // Returns the first item in the title field arrays, or returns - * // the entire title field if the array is empty or the field is another type. - * ifError(arrayGet(field("title"), 0), field("title")) - * ``` - * - * @param tryExpr The try expression. - * @param catchExpr The catch expression that will be evaluated and returned if the [tryExpr] - * produces an error. - * @return A new [Expression] representing the ifError operation. - */ - -public com.google.firebase.firestore.pipeline.Expression ifError(com.google.firebase.firestore.pipeline.Expression tryExpr, com.google.firebase.firestore.pipeline.Expression catchExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [catchExpr] argument if there is an error, else return - * the result of the [tryExpr] argument evaluation. - * - * This overload will return [BooleanExpression] when both parameters are also - * [BooleanExpression]. - * - * ```kotlin - * // Returns the result of the boolean expression, or false if it errors. - * ifError(field("is_premium"), false) - * ``` - * - * @param tryExpr The try boolean expression. - * @param catchExpr The catch boolean expression that will be evaluated and returned if the - * [tryExpr] produces an error. - * @return A new [BooleanExpression] representing the ifError operation. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression ifError(com.google.firebase.firestore.pipeline.BooleanExpression tryExpr, com.google.firebase.firestore.pipeline.BooleanExpression catchExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that checks if a given expression produces an error. - * - * ```kotlin - * // Check if the result of a calculation is an error - * isError(arrayContains(field("title"), 1)) - * ``` - * - * @param expr The expression to check. - * @return A new [BooleanExpression] representing the `isError` check. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression isError(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [catchValue] argument if there is an error, else - * return the result of the [tryExpr] argument evaluation. - * - * ```kotlin - * // Returns the first item in the title field arrays, or returns "Default Title" - * ifError(arrayGet(field("title"), 0), "Default Title") - * ``` - * - * @param tryExpr The try expression. - * @param catchValue The value that will be returned if the [tryExpr] produces an error. - * @return A new [Expression] representing the ifError operation. - */ - -public com.google.firebase.firestore.pipeline.Expression ifError(com.google.firebase.firestore.pipeline.Expression tryExpr, java.lang.Object catchValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [elseExpr] argument if [ifExpr] is absent, else return - * the result of the [ifExpr] argument evaluation. - * - * ```kotlin - * // Returns the value of the optional field 'optional_field', or returns 'default_value' - * // if the field is absent. - * ifAbsent(field("optional_field"), "default_value") - * ``` - * - * @param ifExpr The expression to check for absence. - * @param elseExpr The expression that will be evaluated and returned if [ifExpr] is absent. - * @return A new [Expression] representing the ifAbsent operation. - */ - -public com.google.firebase.firestore.pipeline.Expression ifAbsent(com.google.firebase.firestore.pipeline.Expression ifExpr, com.google.firebase.firestore.pipeline.Expression elseExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [elseValue] argument if [ifExpr] is absent, else - * return the result of the [ifExpr] argument evaluation. - * - * ```kotlin - * // Returns the value of the optional field 'optional_field', or returns 'default_value' - * // if the field is absent. - * ifAbsent(field("optional_field"), "default_value") - * ``` - * - * @param ifExpr The expression to check for absence. - * @param elseValue The value that will be returned if [ifExpr] is absent. - * @return A new [Expression] representing the ifAbsent operation. - */ - -public com.google.firebase.firestore.pipeline.Expression ifAbsent(com.google.firebase.firestore.pipeline.Expression ifExpr, java.lang.Object elseValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [elseExpr] argument if [ifFieldName] is absent, else - * return the value of the field. - * - * ```kotlin - * // Returns the value of the optional field 'optional_field', or returns the value of - * // 'default_field' if 'optional_field' is absent. - * ifAbsent("optional_field", field("default_field")) - * ``` - * - * @param ifFieldName The field to check for absence. - * @param elseExpr The expression that will be evaluated and returned if [ifFieldName] is - * absent. - * @return A new [Expression] representing the ifAbsent operation. - */ - -public com.google.firebase.firestore.pipeline.Expression ifAbsent(java.lang.String ifFieldName, com.google.firebase.firestore.pipeline.Expression elseExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [elseValue] argument if [ifFieldName] is absent, else - * return the value of the field. - * - * ```kotlin - * // Returns the value of the optional field 'optional_field', or returns 'default_value' - * // if the field is absent. - * ifAbsent("optional_field", "default_value") - * ``` - * - * @param ifFieldName The field to check for absence. - * @param elseValue The value that will be returned if [ifFieldName] is absent. - * @return A new [Expression] representing the ifAbsent operation. - */ - -public com.google.firebase.firestore.pipeline.Expression ifAbsent(java.lang.String ifFieldName, java.lang.Object elseValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [elseExpr] argument if [ifExpr] evaluates to null, - * else return the result of the [ifExpr] argument evaluation. - * - * This function provides a fallback for both absent and explicit null values. In contrast, - * [ifAbsent] only triggers for missing fields. - * - * ```kotlin - * // Returns the user's preferred name, or if that is null, returns their full name. - * ifNull(field("preferredName"), field("fullName")) - * ``` - * - * @param ifExpr The expression to check for null. - * @param elseExpr The expression that will be evaluated and returned if [ifExpr] is null. - * @return A new [Expression] representing the ifNull operation. - */ - -public com.google.firebase.firestore.pipeline.Expression ifNull(com.google.firebase.firestore.pipeline.Expression ifExpr, com.google.firebase.firestore.pipeline.Expression elseExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [elseValue] argument if [ifExpr] evaluates to null, - * else return the result of the [ifExpr] argument evaluation. - * - * This function provides a fallback for both absent and explicit null values. In contrast, - * [ifAbsent] only triggers for missing fields. - * - * ```kotlin - * // Returns the user's display name, or returns "Anonymous" if the field is null. - * ifNull(field("displayName"), "Anonymous") - * ``` - * - * @param ifExpr The expression to check for null. - * @param elseValue The value that will be returned if [ifExpr] evaluates to null. - * @return A new [Expression] representing the ifNull operation. - */ - -public com.google.firebase.firestore.pipeline.Expression ifNull(com.google.firebase.firestore.pipeline.Expression ifExpr, java.lang.Object elseValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [elseExpr] argument if [ifFieldName] field is null, - * else return the value of the field. - * - * ```kotlin - * // Returns the user's preferred name, or if that is null, returns their full name. - * ifNull("preferredName", field("fullName")) - * ``` - * - * @param ifFieldName The field to check for null. - * @param elseExpr The expression that will be evaluated and returned if [ifFieldName] is null. - * @return A new [Expression] representing the ifNull operation. - */ - -public com.google.firebase.firestore.pipeline.Expression ifNull(java.lang.String ifFieldName, com.google.firebase.firestore.pipeline.Expression elseExpr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the [elseValue] argument if [ifFieldName] field is null, - * else return the value of the field. - * - * ```kotlin - * // Returns the user's display name, or returns "Anonymous" if the field is null. - * ifNull("displayName", "Anonymous") - * ``` - * - * @param ifFieldName The field to check for null. - * @param elseValue The value that will be returned if [ifFieldName] is null. - * @return A new [Expression] representing the ifNull operation. - */ - -public com.google.firebase.firestore.pipeline.Expression ifNull(java.lang.String ifFieldName, java.lang.Object elseValue) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first non-null, non-absent argument, without - * evaluating the rest of the arguments. When all arguments are null or absent, returns the last - * argument. - * - * ```kotlin - * // Returns the value of the first non-null, non-absent field among 'preferredName', 'fullName', - * // or the last argument if all previous fields are null. - * coalesce(field("preferredName"), field("fullName"), constant("Anonymous")) - * ``` - * - * @param expression The first expression to check for null. - * @param replacement The fallback expression or value if the first one is null. - * @param others Optional additional expressions to check if previous ones are null. - * @return A new [Expression] representing the coalesce operation. - */ - -public com.google.firebase.firestore.pipeline.Expression coalesce(com.google.firebase.firestore.pipeline.Expression expression, java.lang.Object replacement, java.lang.Object... others) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the first non-null, non-absent argument, without - * evaluating the rest of the arguments. When all arguments are null or absent, returns the last - * argument. - * - * ```kotlin - * // Returns the value of the first non-null, non-absent field among 'preferredName', 'fullName', - * // or the last argument if all previous fields are null. - * coalesce("preferredName", field("fullName"), constant("Anonymous")) - * ``` - * - * @param fieldName The name of the first field to check for null. - * @param replacement The fallback expression or value if the first one is null. - * @param others Optional additional expressions to check if previous ones are null. - * @return A new [Expression] representing the coalesce operation. - */ - -public com.google.firebase.firestore.pipeline.Expression coalesce(java.lang.String fieldName, java.lang.Object replacement, java.lang.Object... others) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the collection ID from a path. - * - * ```kotlin - * // Get the collection ID from the 'path' field - * collectionId(field("path")) - * ``` - * - * @param path An expression the evaluates to a path. - * @return A new [Expression] representing the collectionId operation. - */ - -public com.google.firebase.firestore.pipeline.Expression collectionId(com.google.firebase.firestore.pipeline.Expression path) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the collection ID from a path. - * - * ```kotlin - * // Get the collection ID from a path field - * collectionId("pathField") - * ``` - * - * @param pathField The string representation of the path. - * @return A new [Expression] representing the collectionId operation. - */ - -public com.google.firebase.firestore.pipeline.Expression collectionId(java.lang.String pathField) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the document ID from a path. - * - * ```kotlin - * // Get the document ID from the 'path' field - * documentId(field("path")) - * ``` - * - * @param documentPath An expression the evaluates to document path. - * @return A new [Expression] representing the documentId operation. - */ - -public com.google.firebase.firestore.pipeline.Expression documentId(com.google.firebase.firestore.pipeline.Expression documentPath) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the document ID from a path. - * - * ```kotlin - * // Get the document ID from a path string - * documentId("projects/p/databases/d/documents/c/d") - * ``` - * - * @param documentPath The string representation of the document path. - * @return A new [Expression] representing the documentId operation. - */ - -public com.google.firebase.firestore.pipeline.Expression documentId(java.lang.String documentPath) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the document ID from a [DocumentReference]. - * - * @param docRef The [DocumentReference]. - * @return A new [Expression] representing the documentId operation. - */ - -public com.google.firebase.firestore.pipeline.Expression documentId(com.google.firebase.firestore.DocumentReference docRef) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the parent document reference of a document reference. - * - * ```kotlin - * // Get the parent document reference of a document reference. - * parent(field("__path__")) - * ``` - * - * @param documentPath An expression evaluating to a document reference. - * @return A new [Expression] representing the parent operation. - */ - -public com.google.firebase.firestore.pipeline.Expression parent(com.google.firebase.firestore.pipeline.Expression documentPath) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the parent document reference of a document reference. - * - * ```kotlin - * // Get the parent document reference of a document reference. - * parent("projects/p/databases/d/documents/c/d") - * ``` - * - * @param documentPath A string path to get the parent from. - * @return A new [Expression] representing the parent operation. - */ - -public com.google.firebase.firestore.pipeline.Expression parent(java.lang.String documentPath) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that returns the parent document reference of a document reference. - * - * ```kotlin - * // Get the parent document reference of a document reference. - * parent(myDocumentReference) - * ``` - * - * @param docRef A [DocumentReference] to get the parent from. - * @return A new [Expression] representing the parent operation. - */ - -public com.google.firebase.firestore.pipeline.Expression parent(com.google.firebase.firestore.DocumentReference docRef) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that retrieves the value of a variable bound via [Pipeline.define]. - * - * Example: - * ```kotlin - * firestore.pipeline().collection("products") - * .define( - * multiply(field("price"), 0.9).as("discountedPrice"), - * add(field("stock"), 10).as("newStock") - * ) - * .where(lessThan(variable("discountedPrice"), 100)) - * .select(field("name"), variable("newStock")); - * ``` - * - * @param name The name of the variable to retrieve. - * @return An [Expression] representing the variable's value. - */ - -public com.google.firebase.firestore.pipeline.Expression variable(java.lang.String name) { throw new RuntimeException("Stub!"); } - -/** - * Creates an expression that represents the current document being processed. - * - * Example: - * ```kotlin - * // Define the current document as a variable "doc" - * firestore.pipeline().collection("books") - * .define(currentDocument().alias("doc")) - * // Access a field from the defined document variable - * .select(variable("doc").getField("title")) - * ``` - * - * @return An [Expression] representing the current document. - */ - -public com.google.firebase.firestore.pipeline.Expression currentDocument() { throw new RuntimeException("Stub!"); } - -/** - * Evaluates to the distance in meters between the location in the specified field and the query - * location. - * - * Note: This Expression can only be used within a `Search` stage. - * - * @example - * ```kotlin - * db.pipeline().collection("restaurants").search( - * SearchStage(query = documentMatches("waffles"), sort = arrayOf(geoDistance("location", GeoPoint(37.0, -122.0)).ascending())) - * ) - * ``` - * - * @param fieldName Specifies the field in the document which contains the first GeoPoint for - * distance computation. - * @param location Compute distance to this GeoPoint. - */ - -public com.google.firebase.firestore.pipeline.Expression geoDistance(java.lang.String fieldName, com.google.firebase.firestore.GeoPoint location) { throw new RuntimeException("Stub!"); } - -/** - * Evaluates to the distance in meters between the location in the specified field and the query - * location. - * - * Note: This Expression can only be used within a `Search` stage. - * - * @example - * ```kotlin - * db.pipeline().collection("restaurants").search( - * SearchStage(query = documentMatches("waffles"), sort = arrayOf(geoDistance(field("location"), GeoPoint(37.0, -122.0)).ascending())) - * ) - * ``` - * - * @param field Specifies the field in the document which contains the first GeoPoint for - * distance computation. - * @param location Compute distance to this GeoPoint. - */ - -public com.google.firebase.firestore.pipeline.Expression geoDistance(com.google.firebase.firestore.pipeline.Field field, com.google.firebase.firestore.GeoPoint location) { throw new RuntimeException("Stub!"); } - -/** - * Perform a full-text search on all indexed search fields in the document. - * - * Note: This Expression can only be used within a `Search` stage. - * - * @example - * ```kotlin - * db.pipeline().collection("restaurants").search( - * SearchStage(query = documentMatches("waffles OR pancakes")) - * ) - * ``` - * - * @param rquery Define the search query using the search DSL. - */ - -public com.google.firebase.firestore.pipeline.BooleanExpression documentMatches(java.lang.String rquery) { throw new RuntimeException("Stub!"); } - -/** - * Evaluates to the search score that reflects the topicality of the document to all of the text - * predicates (for example: `documentMatches`) in the search query. If `SearchStage.query` is - * not set or does not contain any text predicates, then this score will always be `0`. - * - * Note: This Expression can only be used within a `Search` stage. - * @example - * ```kotlin - * db.pipeline().collection("restaurants").search( - * SearchStage(query = documentMatches("waffles"), sort = arrayOf(score().descending())) - * ) - * ``` - */ - -public com.google.firebase.firestore.pipeline.Expression score() { throw new RuntimeException("Stub!"); } -} - -} - - - -// File: Field.java -// Copyright 2025 Google LLC -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file 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. -// Ensure this overload exists or is correctly placed -// /** -// * Perform a full-text search on the specified field. -// * -// * Note: This Expression can only be used within a `Search` stage. -// * -// * @example -// * ```kotlin -// * db.pipeline().collection("restaurants").search( -// * SearchStage(query = matches("menu", "waffles")) -// * ) -// * ``` -// * -// * @param fieldName Perform search on this field. -// * @param rquery Define the search query using the search DSL. -// */ -// // TODO(search) this is internal until supported by the backend -// @Beta -// @JvmStatic -// internal fun matches(fieldName: String, rquery: String): BooleanExpression = -// matches(field(fieldName), rquery) -// -// /** -// * Perform a full-text search on the specified field. -// * -// * Note: This Expression can only be used within a `Search` stage. -// * -// * @example -// * ```kotlin -// * db.pipeline().collection("restaurants").search( -// * SearchStage(query = matches(field("menu"), "waffles")) -// * ) -// * ``` -// * -// * @param field Perform search on this field. -// * @param rquery Define the search query using the search DSL. -// */ -// // TODO(search) this is internal until supported by the backend -// @Beta -// @JvmStatic -// internal fun matches(field: Field, rquery: String): BooleanExpression = -// BooleanFunctionExpression("matches", notImplemented, field, constant(rquery)) -// /** -// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search -// query -// * in `bold`. -// * -// * This Expression can only be used within a `Search` stage. -// * -// * @example -// * ```kotlin -// * db.pipeline().collection("restaurants").search( -// * SearchStage(query = documentMatches("waffles"), addFields = arrayOf(snippet("menu", -// "waffles").alias("snippet"))) -// * ) -// * ``` -// * -// * @param fieldName Search the specified field for matching terms. -// * @param rquery Define the search query using the search DSL. -// */ -// @Beta -// @JvmStatic -// fun snippet(fieldName: String, rquery: String): Expression = -// FunctionExpression("snippet", notImplemented, field(fieldName), constant(rquery)) -// /** -// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search -// query -// * in `bold`. -// * -// * This Expression can only be used within a `Search` stage. -// * -// * @param fieldName Search the specified field for matching terms. -// * @param options Define how the snippet is generated. -// */ -// // TODO(search) snippet with options is internal and unimplemented until supported by the -// // backend -// @Beta -// @JvmStatic -// internal fun snippet(fieldName: String, options: SnippetOptions): Expression { -// throw NotImplementedError("Not implemented") -// } -// /** -// * Evaluates if the value in the field specified by `fieldName` is between the evaluated -// values -// * for `lowerBound` (inclusive) and `upperBound` (inclusive). -// * -// * @param fieldName Determine if this field is between two bounds. -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// */ -// // TODO(search) between is internal and unimplemented until supported by the backend -// @JvmStatic -// internal fun between( -// fieldName: String, -// lowerBound: Expression, -// upperBound: Expression -// ): BooleanExpression = -// BooleanFunctionExpression("between", notImplemented, fieldName, lowerBound, upperBound) -// /** -// * Evaluates if the value in the field specified by `fieldName` is between the values for -// * `lowerBound` (inclusive) and `upperBound` (inclusive). -// * -// * @param fieldName Determine if this field is between two bounds. -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// */ -// @JvmStatic -// internal fun between(fieldName: String, lowerBound: Any, upperBound: Any): -// BooleanExpression = -// between(fieldName, toExprOrConstant(lowerBound), toExprOrConstant(upperBound)) -// /** -// * Evaluates if the result of the specified `expression` is between the results of -// `lowerBound` -// * (inclusive) and `upperBound` (inclusive). -// * -// * @param expression Determine if the result of this expression is between two bounds. -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// */ -// @JvmStatic -// internal fun between( -// expression: Expression, -// lowerBound: Expression, -// upperBound: Expression -// ): BooleanExpression = -// BooleanFunctionExpression("between", notImplemented, expression, lowerBound, upperBound) -// /** -// * Evaluates if the result of the specified `expression` is between the `lowerBound` -// (inclusive) -// * and `upperBound` (inclusive). -// * -// * @param expression Determine if the result of this expression is between two bounds. -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// */ -// @JvmStatic -// internal fun between( -// expression: Expression, -// lowerBound: Any, -// upperBound: Any -// ): BooleanExpression = -// between(expression, toExprOrConstant(lowerBound), toExprOrConstant(upperBound)) -// // TODO(search) SnippetOptions is internal until supported by the backend -// @Beta -// internal class SnippetOptions private constructor(options: InternalOptions) : -// AbstractOptions(options) { -// /** Creates a new, empty `SnippetOptions` object. */ -// constructor(rquery: String) : this(InternalOptions.EMPTY.with("query", encodeValue(rquery))) -// -// fun withMaxSnippetWidth(max: Int): SnippetOptions { -// return with("max_snippet_width", encodeValue(max)) -// } -// -// fun withMaxSnippets(max: Int): SnippetOptions { -// return with("max_snippets", encodeValue(max)) -// } -// -// fun withSeparator(separator: String): SnippetOptions { -// return with("separator", encodeValue(separator)) -// } -// -// internal override fun self(options: InternalOptions): SnippetOptions { -// return SnippetOptions(options) -// } -// } -// /** -// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search query -// in -// * `bold`. -// * -// * Note: This Expression can only be used within a `Search` stage. -// * -// * @param rquery Define the search query using the search DTS. -// */ -// @Beta -// fun snippet(rquery: String): Expression = -// FunctionExpression( -// "snippet", -// notImplemented, -// arrayOf(this, constant(rquery)), -// SnippetOptions(rquery).options -// ) -// -// /** -// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search query -// in -// * `bold`. -// * -// * Note: This Expression can only be used within a `Search` stage. -// * -// * @param options Define how the snippet is generated. -// * -// * TODO(search) implement snippet with SnippetOptions - out of scope for first release -// */ -// @Beta -// internal fun snippet(options: SnippetOptions): Expression { -// throw NotImplementedError() -// } -// -// /** -// * Evaluates if the result of this `expression` is between the `lowerBound` (inclusive) and -// * `upperBound` (inclusive). -// * -// * @example -// * ``` -// * // Evaluate if the 'tireWidth' is between 2.2 and 2.4 -// * field('tireWidth').between(constant(2.2), constant(2.4)) -// * -// * // This is functionally equivalent to -// * and( -// * field('tireWidth').greaterThanOrEqual(constant(2.2)), -// * field('tireWidth').lessThanOrEqual(constant(2.4))) -// * ``` -// * -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// * -// * TODO(search) publish between - out of scope for first release -// */ -// internal fun between(lowerBound: Expression, upperBound: Expression): BooleanExpression = -// Companion.between(this, lowerBound, upperBound) -// -// /** -// * Evaluates if the result of this `expression` is between the `lowerBound` (inclusive) and -// * `upperBound` (inclusive). -// * -// * @example -// * ``` -// * // Evaluate if the 'tireWidth' is between 2.2 and 2.4 -// * field('tireWidth').between(2.2, 2.4) -// * -// * // This is functionally equivalent to -// * and( -// * field('tireWidth').greaterThanOrEqual(2.2), -// * field('tireWidth').lessThanOrEqual(2.4)) -// * ``` -// * -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// * -// * TODO(search) publish between - out of scope for first release -// */ -// internal fun between(lowerBound: Any, upperBound: Any): BooleanExpression = -// Companion.between(this, lowerBound, upperBound) -// -// This block runs only if fieldValue is not null. -// This value is used if getField() returns null. -// /** -// * Perform a full-text search on this field. -// * -// * Note: This Expression can only be used within a `Search` stage. -// * -// * @param rquery Define the search query using the rquery DTS. -// */ -// @Beta internal fun matches(rquery: String): BooleanExpression = matches(this, rquery) -package com.google.firebase.firestore.pipeline; - - -/** - * Represents a reference to a field in a Firestore document. - * - * [Field] references are used to access document field values in expressions and to specify fields - * for sorting, filtering, and projecting data in Firestore pipelines. - * - * You can create a [Field] instance using the static [Expression.field] method: - */ - -@SuppressWarnings({"unchecked", "deprecation", "all"}) -public final class Field extends com.google.firebase.firestore.pipeline.Selectable { - -Field() { throw new RuntimeException("Stub!"); } - -public boolean equals(java.lang.Object other) { throw new RuntimeException("Stub!"); } - -public int hashCode() { throw new RuntimeException("Stub!"); } - -/** - * Evaluates to the distance in meters between the location specified by this field and the query - * location. - * - * Note: This Expression can only be used within a `Search` stage. - * - * @param location Compute distance to this GeoPoint. - */ - -public com.google.firebase.firestore.pipeline.Expression geoDistance(com.google.firebase.firestore.GeoPoint location) { throw new RuntimeException("Stub!"); } - -public static final com.google.firebase.firestore.pipeline.Field.Companion Companion; -static { Companion = null; } -@SuppressWarnings({"unchecked", "deprecation", "all"}) -public static final class Companion { - -Companion() { throw new RuntimeException("Stub!"); } -} - -} - - - -// File: FunctionExpression.java -// Copyright 2025 Google LLC -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file 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. -// Ensure this overload exists or is correctly placed -// /** -// * Perform a full-text search on the specified field. -// * -// * Note: This Expression can only be used within a `Search` stage. -// * -// * @example -// * ```kotlin -// * db.pipeline().collection("restaurants").search( -// * SearchStage(query = matches("menu", "waffles")) -// * ) -// * ``` -// * -// * @param fieldName Perform search on this field. -// * @param rquery Define the search query using the search DSL. -// */ -// // TODO(search) this is internal until supported by the backend -// @Beta -// @JvmStatic -// internal fun matches(fieldName: String, rquery: String): BooleanExpression = -// matches(field(fieldName), rquery) -// -// /** -// * Perform a full-text search on the specified field. -// * -// * Note: This Expression can only be used within a `Search` stage. -// * -// * @example -// * ```kotlin -// * db.pipeline().collection("restaurants").search( -// * SearchStage(query = matches(field("menu"), "waffles")) -// * ) -// * ``` -// * -// * @param field Perform search on this field. -// * @param rquery Define the search query using the search DSL. -// */ -// // TODO(search) this is internal until supported by the backend -// @Beta -// @JvmStatic -// internal fun matches(field: Field, rquery: String): BooleanExpression = -// BooleanFunctionExpression("matches", notImplemented, field, constant(rquery)) -// /** -// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search -// query -// * in `bold`. -// * -// * This Expression can only be used within a `Search` stage. -// * -// * @example -// * ```kotlin -// * db.pipeline().collection("restaurants").search( -// * SearchStage(query = documentMatches("waffles"), addFields = arrayOf(snippet("menu", -// "waffles").alias("snippet"))) -// * ) -// * ``` -// * -// * @param fieldName Search the specified field for matching terms. -// * @param rquery Define the search query using the search DSL. -// */ -// @Beta -// @JvmStatic -// fun snippet(fieldName: String, rquery: String): Expression = -// FunctionExpression("snippet", notImplemented, field(fieldName), constant(rquery)) -// /** -// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search -// query -// * in `bold`. -// * -// * This Expression can only be used within a `Search` stage. -// * -// * @param fieldName Search the specified field for matching terms. -// * @param options Define how the snippet is generated. -// */ -// // TODO(search) snippet with options is internal and unimplemented until supported by the -// // backend -// @Beta -// @JvmStatic -// internal fun snippet(fieldName: String, options: SnippetOptions): Expression { -// throw NotImplementedError("Not implemented") -// } -// /** -// * Evaluates if the value in the field specified by `fieldName` is between the evaluated -// values -// * for `lowerBound` (inclusive) and `upperBound` (inclusive). -// * -// * @param fieldName Determine if this field is between two bounds. -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// */ -// // TODO(search) between is internal and unimplemented until supported by the backend -// @JvmStatic -// internal fun between( -// fieldName: String, -// lowerBound: Expression, -// upperBound: Expression -// ): BooleanExpression = -// BooleanFunctionExpression("between", notImplemented, fieldName, lowerBound, upperBound) -// /** -// * Evaluates if the value in the field specified by `fieldName` is between the values for -// * `lowerBound` (inclusive) and `upperBound` (inclusive). -// * -// * @param fieldName Determine if this field is between two bounds. -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// */ -// @JvmStatic -// internal fun between(fieldName: String, lowerBound: Any, upperBound: Any): -// BooleanExpression = -// between(fieldName, toExprOrConstant(lowerBound), toExprOrConstant(upperBound)) -// /** -// * Evaluates if the result of the specified `expression` is between the results of -// `lowerBound` -// * (inclusive) and `upperBound` (inclusive). -// * -// * @param expression Determine if the result of this expression is between two bounds. -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// */ -// @JvmStatic -// internal fun between( -// expression: Expression, -// lowerBound: Expression, -// upperBound: Expression -// ): BooleanExpression = -// BooleanFunctionExpression("between", notImplemented, expression, lowerBound, upperBound) -// /** -// * Evaluates if the result of the specified `expression` is between the `lowerBound` -// (inclusive) -// * and `upperBound` (inclusive). -// * -// * @param expression Determine if the result of this expression is between two bounds. -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// */ -// @JvmStatic -// internal fun between( -// expression: Expression, -// lowerBound: Any, -// upperBound: Any -// ): BooleanExpression = -// between(expression, toExprOrConstant(lowerBound), toExprOrConstant(upperBound)) -// // TODO(search) SnippetOptions is internal until supported by the backend -// @Beta -// internal class SnippetOptions private constructor(options: InternalOptions) : -// AbstractOptions(options) { -// /** Creates a new, empty `SnippetOptions` object. */ -// constructor(rquery: String) : this(InternalOptions.EMPTY.with("query", encodeValue(rquery))) -// -// fun withMaxSnippetWidth(max: Int): SnippetOptions { -// return with("max_snippet_width", encodeValue(max)) -// } -// -// fun withMaxSnippets(max: Int): SnippetOptions { -// return with("max_snippets", encodeValue(max)) -// } -// -// fun withSeparator(separator: String): SnippetOptions { -// return with("separator", encodeValue(separator)) -// } -// -// internal override fun self(options: InternalOptions): SnippetOptions { -// return SnippetOptions(options) -// } -// } -// /** -// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search query -// in -// * `bold`. -// * -// * Note: This Expression can only be used within a `Search` stage. -// * -// * @param rquery Define the search query using the search DTS. -// */ -// @Beta -// fun snippet(rquery: String): Expression = -// FunctionExpression( -// "snippet", -// notImplemented, -// arrayOf(this, constant(rquery)), -// SnippetOptions(rquery).options -// ) -// -// /** -// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search query -// in -// * `bold`. -// * -// * Note: This Expression can only be used within a `Search` stage. -// * -// * @param options Define how the snippet is generated. -// * -// * TODO(search) implement snippet with SnippetOptions - out of scope for first release -// */ -// @Beta -// internal fun snippet(options: SnippetOptions): Expression { -// throw NotImplementedError() -// } -// -// /** -// * Evaluates if the result of this `expression` is between the `lowerBound` (inclusive) and -// * `upperBound` (inclusive). -// * -// * @example -// * ``` -// * // Evaluate if the 'tireWidth' is between 2.2 and 2.4 -// * field('tireWidth').between(constant(2.2), constant(2.4)) -// * -// * // This is functionally equivalent to -// * and( -// * field('tireWidth').greaterThanOrEqual(constant(2.2)), -// * field('tireWidth').lessThanOrEqual(constant(2.4))) -// * ``` -// * -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// * -// * TODO(search) publish between - out of scope for first release -// */ -// internal fun between(lowerBound: Expression, upperBound: Expression): BooleanExpression = -// Companion.between(this, lowerBound, upperBound) -// -// /** -// * Evaluates if the result of this `expression` is between the `lowerBound` (inclusive) and -// * `upperBound` (inclusive). -// * -// * @example -// * ``` -// * // Evaluate if the 'tireWidth' is between 2.2 and 2.4 -// * field('tireWidth').between(2.2, 2.4) -// * -// * // This is functionally equivalent to -// * and( -// * field('tireWidth').greaterThanOrEqual(2.2), -// * field('tireWidth').lessThanOrEqual(2.4)) -// * ``` -// * -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// * -// * TODO(search) publish between - out of scope for first release -// */ -// internal fun between(lowerBound: Any, upperBound: Any): BooleanExpression = -// Companion.between(this, lowerBound, upperBound) -// -// This block runs only if fieldValue is not null. -// This value is used if getField() returns null. -// /** -// * Perform a full-text search on this field. -// * -// * Note: This Expression can only be used within a `Search` stage. -// * -// * @param rquery Define the search query using the rquery DTS. -// */ -// @Beta internal fun matches(rquery: String): BooleanExpression = matches(this, rquery) -package com.google.firebase.firestore.pipeline; - - -/** - * This class defines the base class for Firestore [Pipeline] functions, which can be evaluated - * within pipeline execution. - * - * Typically, you would not use this class or its children directly. Use either the functions like - * [and], [equal], or the methods on [Expression] ([Expression.equal]), [Expression.lessThan], etc) - * to construct new [FunctionExpression] instances. - */ - -@SuppressWarnings({"unchecked", "deprecation", "all"}) -public class FunctionExpression extends com.google.firebase.firestore.pipeline.Expression { - -FunctionExpression() { throw new RuntimeException("Stub!"); } - -public boolean equals(java.lang.Object other) { throw new RuntimeException("Stub!"); } - -public int hashCode() { throw new RuntimeException("Stub!"); } -} - - - -// File: Ordering.java -// Copyright 2025 Google LLC -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file 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. -// Ensure this overload exists or is correctly placed -// /** -// * Perform a full-text search on the specified field. -// * -// * Note: This Expression can only be used within a `Search` stage. -// * -// * @example -// * ```kotlin -// * db.pipeline().collection("restaurants").search( -// * SearchStage(query = matches("menu", "waffles")) -// * ) -// * ``` -// * -// * @param fieldName Perform search on this field. -// * @param rquery Define the search query using the search DSL. -// */ -// // TODO(search) this is internal until supported by the backend -// @Beta -// @JvmStatic -// internal fun matches(fieldName: String, rquery: String): BooleanExpression = -// matches(field(fieldName), rquery) -// -// /** -// * Perform a full-text search on the specified field. -// * -// * Note: This Expression can only be used within a `Search` stage. -// * -// * @example -// * ```kotlin -// * db.pipeline().collection("restaurants").search( -// * SearchStage(query = matches(field("menu"), "waffles")) -// * ) -// * ``` -// * -// * @param field Perform search on this field. -// * @param rquery Define the search query using the search DSL. -// */ -// // TODO(search) this is internal until supported by the backend -// @Beta -// @JvmStatic -// internal fun matches(field: Field, rquery: String): BooleanExpression = -// BooleanFunctionExpression("matches", notImplemented, field, constant(rquery)) -// /** -// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search -// query -// * in `bold`. -// * -// * This Expression can only be used within a `Search` stage. -// * -// * @example -// * ```kotlin -// * db.pipeline().collection("restaurants").search( -// * SearchStage(query = documentMatches("waffles"), addFields = arrayOf(snippet("menu", -// "waffles").alias("snippet"))) -// * ) -// * ``` -// * -// * @param fieldName Search the specified field for matching terms. -// * @param rquery Define the search query using the search DSL. -// */ -// @Beta -// @JvmStatic -// fun snippet(fieldName: String, rquery: String): Expression = -// FunctionExpression("snippet", notImplemented, field(fieldName), constant(rquery)) -// /** -// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search -// query -// * in `bold`. -// * -// * This Expression can only be used within a `Search` stage. -// * -// * @param fieldName Search the specified field for matching terms. -// * @param options Define how the snippet is generated. -// */ -// // TODO(search) snippet with options is internal and unimplemented until supported by the -// // backend -// @Beta -// @JvmStatic -// internal fun snippet(fieldName: String, options: SnippetOptions): Expression { -// throw NotImplementedError("Not implemented") -// } -// /** -// * Evaluates if the value in the field specified by `fieldName` is between the evaluated -// values -// * for `lowerBound` (inclusive) and `upperBound` (inclusive). -// * -// * @param fieldName Determine if this field is between two bounds. -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// */ -// // TODO(search) between is internal and unimplemented until supported by the backend -// @JvmStatic -// internal fun between( -// fieldName: String, -// lowerBound: Expression, -// upperBound: Expression -// ): BooleanExpression = -// BooleanFunctionExpression("between", notImplemented, fieldName, lowerBound, upperBound) -// /** -// * Evaluates if the value in the field specified by `fieldName` is between the values for -// * `lowerBound` (inclusive) and `upperBound` (inclusive). -// * -// * @param fieldName Determine if this field is between two bounds. -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// */ -// @JvmStatic -// internal fun between(fieldName: String, lowerBound: Any, upperBound: Any): -// BooleanExpression = -// between(fieldName, toExprOrConstant(lowerBound), toExprOrConstant(upperBound)) -// /** -// * Evaluates if the result of the specified `expression` is between the results of -// `lowerBound` -// * (inclusive) and `upperBound` (inclusive). -// * -// * @param expression Determine if the result of this expression is between two bounds. -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// */ -// @JvmStatic -// internal fun between( -// expression: Expression, -// lowerBound: Expression, -// upperBound: Expression -// ): BooleanExpression = -// BooleanFunctionExpression("between", notImplemented, expression, lowerBound, upperBound) -// /** -// * Evaluates if the result of the specified `expression` is between the `lowerBound` -// (inclusive) -// * and `upperBound` (inclusive). -// * -// * @param expression Determine if the result of this expression is between two bounds. -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// */ -// @JvmStatic -// internal fun between( -// expression: Expression, -// lowerBound: Any, -// upperBound: Any -// ): BooleanExpression = -// between(expression, toExprOrConstant(lowerBound), toExprOrConstant(upperBound)) -// // TODO(search) SnippetOptions is internal until supported by the backend -// @Beta -// internal class SnippetOptions private constructor(options: InternalOptions) : -// AbstractOptions(options) { -// /** Creates a new, empty `SnippetOptions` object. */ -// constructor(rquery: String) : this(InternalOptions.EMPTY.with("query", encodeValue(rquery))) -// -// fun withMaxSnippetWidth(max: Int): SnippetOptions { -// return with("max_snippet_width", encodeValue(max)) -// } -// -// fun withMaxSnippets(max: Int): SnippetOptions { -// return with("max_snippets", encodeValue(max)) -// } -// -// fun withSeparator(separator: String): SnippetOptions { -// return with("separator", encodeValue(separator)) -// } -// -// internal override fun self(options: InternalOptions): SnippetOptions { -// return SnippetOptions(options) -// } -// } -// /** -// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search query -// in -// * `bold`. -// * -// * Note: This Expression can only be used within a `Search` stage. -// * -// * @param rquery Define the search query using the search DTS. -// */ -// @Beta -// fun snippet(rquery: String): Expression = -// FunctionExpression( -// "snippet", -// notImplemented, -// arrayOf(this, constant(rquery)), -// SnippetOptions(rquery).options -// ) -// -// /** -// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search query -// in -// * `bold`. -// * -// * Note: This Expression can only be used within a `Search` stage. -// * -// * @param options Define how the snippet is generated. -// * -// * TODO(search) implement snippet with SnippetOptions - out of scope for first release -// */ -// @Beta -// internal fun snippet(options: SnippetOptions): Expression { -// throw NotImplementedError() -// } -// -// /** -// * Evaluates if the result of this `expression` is between the `lowerBound` (inclusive) and -// * `upperBound` (inclusive). -// * -// * @example -// * ``` -// * // Evaluate if the 'tireWidth' is between 2.2 and 2.4 -// * field('tireWidth').between(constant(2.2), constant(2.4)) -// * -// * // This is functionally equivalent to -// * and( -// * field('tireWidth').greaterThanOrEqual(constant(2.2)), -// * field('tireWidth').lessThanOrEqual(constant(2.4))) -// * ``` -// * -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// * -// * TODO(search) publish between - out of scope for first release -// */ -// internal fun between(lowerBound: Expression, upperBound: Expression): BooleanExpression = -// Companion.between(this, lowerBound, upperBound) -// -// /** -// * Evaluates if the result of this `expression` is between the `lowerBound` (inclusive) and -// * `upperBound` (inclusive). -// * -// * @example -// * ``` -// * // Evaluate if the 'tireWidth' is between 2.2 and 2.4 -// * field('tireWidth').between(2.2, 2.4) -// * -// * // This is functionally equivalent to -// * and( -// * field('tireWidth').greaterThanOrEqual(2.2), -// * field('tireWidth').lessThanOrEqual(2.4)) -// * ``` -// * -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// * -// * TODO(search) publish between - out of scope for first release -// */ -// internal fun between(lowerBound: Any, upperBound: Any): BooleanExpression = -// Companion.between(this, lowerBound, upperBound) -// -// This block runs only if fieldValue is not null. -// This value is used if getField() returns null. -// /** -// * Perform a full-text search on this field. -// * -// * Note: This Expression can only be used within a `Search` stage. -// * -// * @param rquery Define the search query using the rquery DTS. -// */ -// @Beta internal fun matches(rquery: String): BooleanExpression = matches(this, rquery) -package com.google.firebase.firestore.pipeline; - - -/** - * Represents an ordering criterion for sorting documents in a Firestore pipeline. - * - * You create [Ordering] instances using the [ascending] and [descending] helper methods. - */ - -@SuppressWarnings({"unchecked", "deprecation", "all"}) -public final class Ordering { - -Ordering() { throw new RuntimeException("Stub!"); } - -public boolean equals(java.lang.Object other) { throw new RuntimeException("Stub!"); } - -public int hashCode() { throw new RuntimeException("Stub!"); } - -public com.google.firebase.firestore.pipeline.Expression getExpr() { throw new RuntimeException("Stub!"); } - -public com.google.firebase.firestore.pipeline.Ordering.Direction getDir() { throw new RuntimeException("Stub!"); } - -/** - * Create an [Ordering] that sorts documents in ascending order based on value of [expr]. - * - * @param expr The order is based on the evaluation of the [Expression]. - * @return A new [Ordering] object with ascending sort by [expr]. - */ - -public static com.google.firebase.firestore.pipeline.Ordering ascending(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an [Ordering] that sorts documents in ascending order based on field. - * - * @param fieldName The name of field to sort documents. - * @return A new [Ordering] object with ascending sort by field. - */ - -public static com.google.firebase.firestore.pipeline.Ordering ascending(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Create an [Ordering] that sorts documents in descending order based on value of [expr]. - * - * @param expr The order is based on the evaluation of the [Expression]. - * @return A new [Ordering] object with descending sort by [expr]. - */ - -public static com.google.firebase.firestore.pipeline.Ordering descending(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an [Ordering] that sorts documents in descending order based on field. - * - * @param fieldName The name of field to sort documents. - * @return A new [Ordering] object with descending sort by field. - */ - -public static com.google.firebase.firestore.pipeline.Ordering descending(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -public static final com.google.firebase.firestore.pipeline.Ordering.Companion Companion; -static { Companion = null; } -@SuppressWarnings({"unchecked", "deprecation", "all"}) -public static final class Companion { - -Companion() { throw new RuntimeException("Stub!"); } - -/** - * Create an [Ordering] that sorts documents in ascending order based on value of [expr]. - * - * @param expr The order is based on the evaluation of the [Expression]. - * @return A new [Ordering] object with ascending sort by [expr]. - */ - -public com.google.firebase.firestore.pipeline.Ordering ascending(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an [Ordering] that sorts documents in ascending order based on field. - * - * @param fieldName The name of field to sort documents. - * @return A new [Ordering] object with ascending sort by field. - */ - -public com.google.firebase.firestore.pipeline.Ordering ascending(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } - -/** - * Create an [Ordering] that sorts documents in descending order based on value of [expr]. - * - * @param expr The order is based on the evaluation of the [Expression]. - * @return A new [Ordering] object with descending sort by [expr]. - */ - -public com.google.firebase.firestore.pipeline.Ordering descending(com.google.firebase.firestore.pipeline.Expression expr) { throw new RuntimeException("Stub!"); } - -/** - * Creates an [Ordering] that sorts documents in descending order based on field. - * - * @param fieldName The name of field to sort documents. - * @return A new [Ordering] object with descending sort by field. - */ - -public com.google.firebase.firestore.pipeline.Ordering descending(java.lang.String fieldName) { throw new RuntimeException("Stub!"); } -} - -@SuppressWarnings({"unchecked", "deprecation", "all"}) -public enum Direction { -ASCENDING, -DESCENDING; - -public error.NonExistentClass getProto() { throw new RuntimeException("Stub!"); } -} - -} - - - -// File: Selectable.java -// Copyright 2025 Google LLC -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file 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. -// Ensure this overload exists or is correctly placed -// /** -// * Perform a full-text search on the specified field. -// * -// * Note: This Expression can only be used within a `Search` stage. -// * -// * @example -// * ```kotlin -// * db.pipeline().collection("restaurants").search( -// * SearchStage(query = matches("menu", "waffles")) -// * ) -// * ``` -// * -// * @param fieldName Perform search on this field. -// * @param rquery Define the search query using the search DSL. -// */ -// // TODO(search) this is internal until supported by the backend -// @Beta -// @JvmStatic -// internal fun matches(fieldName: String, rquery: String): BooleanExpression = -// matches(field(fieldName), rquery) -// -// /** -// * Perform a full-text search on the specified field. -// * -// * Note: This Expression can only be used within a `Search` stage. -// * -// * @example -// * ```kotlin -// * db.pipeline().collection("restaurants").search( -// * SearchStage(query = matches(field("menu"), "waffles")) -// * ) -// * ``` -// * -// * @param field Perform search on this field. -// * @param rquery Define the search query using the search DSL. -// */ -// // TODO(search) this is internal until supported by the backend -// @Beta -// @JvmStatic -// internal fun matches(field: Field, rquery: String): BooleanExpression = -// BooleanFunctionExpression("matches", notImplemented, field, constant(rquery)) -// /** -// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search -// query -// * in `bold`. -// * -// * This Expression can only be used within a `Search` stage. -// * -// * @example -// * ```kotlin -// * db.pipeline().collection("restaurants").search( -// * SearchStage(query = documentMatches("waffles"), addFields = arrayOf(snippet("menu", -// "waffles").alias("snippet"))) -// * ) -// * ``` -// * -// * @param fieldName Search the specified field for matching terms. -// * @param rquery Define the search query using the search DSL. -// */ -// @Beta -// @JvmStatic -// fun snippet(fieldName: String, rquery: String): Expression = -// FunctionExpression("snippet", notImplemented, field(fieldName), constant(rquery)) -// /** -// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search -// query -// * in `bold`. -// * -// * This Expression can only be used within a `Search` stage. -// * -// * @param fieldName Search the specified field for matching terms. -// * @param options Define how the snippet is generated. -// */ -// // TODO(search) snippet with options is internal and unimplemented until supported by the -// // backend -// @Beta -// @JvmStatic -// internal fun snippet(fieldName: String, options: SnippetOptions): Expression { -// throw NotImplementedError("Not implemented") -// } -// /** -// * Evaluates if the value in the field specified by `fieldName` is between the evaluated -// values -// * for `lowerBound` (inclusive) and `upperBound` (inclusive). -// * -// * @param fieldName Determine if this field is between two bounds. -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// */ -// // TODO(search) between is internal and unimplemented until supported by the backend -// @JvmStatic -// internal fun between( -// fieldName: String, -// lowerBound: Expression, -// upperBound: Expression -// ): BooleanExpression = -// BooleanFunctionExpression("between", notImplemented, fieldName, lowerBound, upperBound) -// /** -// * Evaluates if the value in the field specified by `fieldName` is between the values for -// * `lowerBound` (inclusive) and `upperBound` (inclusive). -// * -// * @param fieldName Determine if this field is between two bounds. -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// */ -// @JvmStatic -// internal fun between(fieldName: String, lowerBound: Any, upperBound: Any): -// BooleanExpression = -// between(fieldName, toExprOrConstant(lowerBound), toExprOrConstant(upperBound)) -// /** -// * Evaluates if the result of the specified `expression` is between the results of -// `lowerBound` -// * (inclusive) and `upperBound` (inclusive). -// * -// * @param expression Determine if the result of this expression is between two bounds. -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// */ -// @JvmStatic -// internal fun between( -// expression: Expression, -// lowerBound: Expression, -// upperBound: Expression -// ): BooleanExpression = -// BooleanFunctionExpression("between", notImplemented, expression, lowerBound, upperBound) -// /** -// * Evaluates if the result of the specified `expression` is between the `lowerBound` -// (inclusive) -// * and `upperBound` (inclusive). -// * -// * @param expression Determine if the result of this expression is between two bounds. -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// */ -// @JvmStatic -// internal fun between( -// expression: Expression, -// lowerBound: Any, -// upperBound: Any -// ): BooleanExpression = -// between(expression, toExprOrConstant(lowerBound), toExprOrConstant(upperBound)) -// // TODO(search) SnippetOptions is internal until supported by the backend -// @Beta -// internal class SnippetOptions private constructor(options: InternalOptions) : -// AbstractOptions(options) { -// /** Creates a new, empty `SnippetOptions` object. */ -// constructor(rquery: String) : this(InternalOptions.EMPTY.with("query", encodeValue(rquery))) -// -// fun withMaxSnippetWidth(max: Int): SnippetOptions { -// return with("max_snippet_width", encodeValue(max)) -// } -// -// fun withMaxSnippets(max: Int): SnippetOptions { -// return with("max_snippets", encodeValue(max)) -// } -// -// fun withSeparator(separator: String): SnippetOptions { -// return with("separator", encodeValue(separator)) -// } -// -// internal override fun self(options: InternalOptions): SnippetOptions { -// return SnippetOptions(options) -// } -// } -// /** -// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search query -// in -// * `bold`. -// * -// * Note: This Expression can only be used within a `Search` stage. -// * -// * @param rquery Define the search query using the search DTS. -// */ -// @Beta -// fun snippet(rquery: String): Expression = -// FunctionExpression( -// "snippet", -// notImplemented, -// arrayOf(this, constant(rquery)), -// SnippetOptions(rquery).options -// ) -// -// /** -// * Evaluates to an HTML-formatted text snippet that highlights terms matching the search query -// in -// * `bold`. -// * -// * Note: This Expression can only be used within a `Search` stage. -// * -// * @param options Define how the snippet is generated. -// * -// * TODO(search) implement snippet with SnippetOptions - out of scope for first release -// */ -// @Beta -// internal fun snippet(options: SnippetOptions): Expression { -// throw NotImplementedError() -// } -// -// /** -// * Evaluates if the result of this `expression` is between the `lowerBound` (inclusive) and -// * `upperBound` (inclusive). -// * -// * @example -// * ``` -// * // Evaluate if the 'tireWidth' is between 2.2 and 2.4 -// * field('tireWidth').between(constant(2.2), constant(2.4)) -// * -// * // This is functionally equivalent to -// * and( -// * field('tireWidth').greaterThanOrEqual(constant(2.2)), -// * field('tireWidth').lessThanOrEqual(constant(2.4))) -// * ``` -// * -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// * -// * TODO(search) publish between - out of scope for first release -// */ -// internal fun between(lowerBound: Expression, upperBound: Expression): BooleanExpression = -// Companion.between(this, lowerBound, upperBound) -// -// /** -// * Evaluates if the result of this `expression` is between the `lowerBound` (inclusive) and -// * `upperBound` (inclusive). -// * -// * @example -// * ``` -// * // Evaluate if the 'tireWidth' is between 2.2 and 2.4 -// * field('tireWidth').between(2.2, 2.4) -// * -// * // This is functionally equivalent to -// * and( -// * field('tireWidth').greaterThanOrEqual(2.2), -// * field('tireWidth').lessThanOrEqual(2.4)) -// * ``` -// * -// * @param lowerBound Lower bound (inclusive). -// * @param upperBound Upper bound (inclusive). -// * -// * TODO(search) publish between - out of scope for first release -// */ -// internal fun between(lowerBound: Any, upperBound: Any): BooleanExpression = -// Companion.between(this, lowerBound, upperBound) -// -// This block runs only if fieldValue is not null. -// This value is used if getField() returns null. -// /** -// * Perform a full-text search on this field. -// * -// * Note: This Expression can only be used within a `Search` stage. -// * -// * @param rquery Define the search query using the rquery DTS. -// */ -// @Beta internal fun matches(rquery: String): BooleanExpression = matches(this, rquery) -package com.google.firebase.firestore.pipeline; - - -/** Expressions that have an alias are [Selectable] */ - -@SuppressWarnings({"unchecked", "deprecation", "all"}) -public abstract class Selectable extends com.google.firebase.firestore.pipeline.Expression { - -/** Expressions that have an alias are [Selectable] */ - -public Selectable() { throw new RuntimeException("Stub!"); } -} - - - diff --git a/firebase-firestore/src/main/assets/pipeline.docs.txt b/firebase-firestore/src/main/assets/pipeline.docs.txt deleted file mode 100644 index 3470a3feaad..00000000000 --- a/firebase-firestore/src/main/assets/pipeline.docs.txt +++ /dev/null @@ -1,1294 +0,0 @@ -// File: Pipeline.java -// Copyright 2025 Google LLC -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file 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. -// Validate document path by converting to DocumentReference -package com.google.firebase.firestore; - - -/** - * A `Pipeline` is composed of a sequence of stages. Each stage processes the output from the - * previous one, and the final stage's output is the result of the pipeline's execution. - * - * **Example usage:** - * - * ```kotlin - * val pipeline = firestore.pipeline() - * .collection("books") - * .where(field("rating").greaterThan(4.5)) - * .sort(field("rating").descending()) - * .limit(2) - * ``` - * - * **Note on Execution:** The stages are conceptual. The Firestore backend may optimize execution - * (e.g., reordering or merging stages) as long as the final result remains the same. - * - * **Important Limitations:** - * - Pipelines operate on a **request/response basis only**. - * - They do **not** utilize or update the local SDK cache. - * - They do **not** support realtime snapshot listeners. - */ - -@SuppressWarnings({"unchecked", "deprecation", "all"}) -public final class Pipeline { - -Pipeline() { throw new RuntimeException("Stub!"); } - -/** - * Executes this pipeline and returns the results as a [Task] of [Snapshot]. - * - * @return A [Task] that will be resolved with the results of the pipeline. - */ - -public com.google.android.gms.tasks.Task execute() { throw new RuntimeException("Stub!"); } - -/** - * Executes this pipeline and returns the results as a [Task] of [Snapshot]. - * - * @param options The [ExecuteOptions] to use to instruct Firestore backend execution. - * @return A [Task] that will be resolved with the results of the pipeline. - */ - -public com.google.android.gms.tasks.Task execute(com.google.firebase.firestore.Pipeline.ExecuteOptions options) { throw new RuntimeException("Stub!"); } - -/** - * Adds a raw stage to the pipeline by specifying the stage name as an argument. This does not - * offer any type safety on the stage params and requires the caller to know the order (and - * optionally names) of parameters accepted by the stage. - * - * This method provides a way to call stages that are supported by the Firestore backend but that - * are not implemented in the SDK version being used. - * - * @param rawStage A [RawStage] object that specifies stage name and parameters. - * @return A new [Pipeline] object with this stage appended to the stage list. - */ - -public com.google.firebase.firestore.Pipeline rawStage(com.google.firebase.firestore.pipeline.RawStage rawStage) { throw new RuntimeException("Stub!"); } - -/** - * Adds new fields to outputs from previous stages. - * - * This stage allows you to compute values on-the-fly based on existing data from previous stages - * or constants. You can use this to create new fields or overwrite existing ones. - * - * The added fields are defined using [Selectable]s, which can be: - * - * - [Field]: References an existing document field. - * - [AliasedExpression]: Represents the result of a expression with an assigned alias name using - * [Expr.alias] - * - * Example: - * ```kotlin - * firestore.pipeline().collection("books") - * .addFields( - * field("rating").as("bookRating"), // Rename 'rating' to 'bookRating' - * add(5, field("quantity")).as("totalCost") // Calculate 'totalCost' - * ) - * ``` - * - * @param field The first field to add to the documents, specified as a [Selectable]. - * @param additionalFields The fields to add to the documents, specified as [Selectable]s. - * @return A new [Pipeline] object with this stage appended to the stage list. - */ - -public com.google.firebase.firestore.Pipeline addFields(com.google.firebase.firestore.pipeline.Selectable field, com.google.firebase.firestore.pipeline.Selectable... additionalFields) { throw new RuntimeException("Stub!"); } - -/** - * Remove fields from outputs of previous stages. - * - * Example: - * ```kotlin - * firestore.pipeline().collection("books") - * .removeFields( - * field("rating"), field("cost") - * ) - * ``` - * - * @param field The first [Field] to remove. - * @param additionalFields Optional additional [Field]s to remove. - * @return A new [Pipeline] object with this stage appended to the stage list. - */ - -public com.google.firebase.firestore.Pipeline removeFields(com.google.firebase.firestore.pipeline.Field field, com.google.firebase.firestore.pipeline.Field... additionalFields) { throw new RuntimeException("Stub!"); } - -/** - * Remove fields from outputs of previous stages. - * - * Example: - * ```kotlin - * firestore.pipeline().collection("books") - * .removeFields( - * "rating", "cost" - * ) - * ``` - * - * @param field The first [String] name of field to remove. - * @param additionalFields Optional additional [String] name of fields to remove. - * @return A new [Pipeline] object with this stage appended to the stage list. - */ - -public com.google.firebase.firestore.Pipeline removeFields(java.lang.String field, java.lang.String... additionalFields) { throw new RuntimeException("Stub!"); } - -/** - * Selects or creates a set of fields from the outputs of previous stages. - * - * The selected fields are defined using [Selectable] expressions or strings, which can be: - * - * - [String]: Name of an existing field - * - [Field]: Reference to an existing field. - * - [AliasedExpression]: Represents the result of a expression with an assigned alias name using - * [Expr.alias] - * - * If no selections are provided, the output of this stage is empty. Use [Pipeline.addFields] - * instead if only additions are desired. - * - * Example: - * ```kotlin - * firestore.pipeline().collection("books") - * .select( - * field("name"), - * field("address").toUppercase().as("upperAddress"), - * ) - * ``` - * - * @param selection The first field to include in the output documents, specified as a - * [Selectable] expression. - * @param additionalSelections Optional additional fields to include in the output documents, - * specified as [Selectable] expressions or string values representing field names. - * @return A new [Pipeline] object with this stage appended to the stage list. - */ - -public com.google.firebase.firestore.Pipeline select(com.google.firebase.firestore.pipeline.Selectable selection, java.lang.Object... additionalSelections) { throw new RuntimeException("Stub!"); } - -/** - * Selects or creates a set of fields from the outputs of previous stages. - * - * The selected fields are defined using [Selectable] expressions, which can be: - * - * - [String]: Name of an existing field - * - [Field]: Reference to an existing field. - * - [AliasedExpression]: Represents the result of a expression with an assigned alias name using - * [Expr.alias] - * - * If no selections are provided, the output of this stage is empty. Use [Pipeline.addFields] - * instead if only additions are desired. - * - * Example: - * ```kotlin - * firestore.collection("books") - * .select("name", "address") - * - * // The above is a shorthand of this: - * firestore.pipeline().collection("books") - * .select(field("name"), field("address")) - * ``` - * - * @param fieldName The first field to include in the output documents, specified as a string - * value representing a field names. - * @param additionalSelections Optional additional fields to include in the output documents, - * specified as [Selectable] expressions or string values representing field names. - * @return A new [Pipeline] object with this stage appended to the stage list. - */ - -public com.google.firebase.firestore.Pipeline select(java.lang.String fieldName, java.lang.Object... additionalSelections) { throw new RuntimeException("Stub!"); } - -/** - * Sorts the documents from previous stages based on one or more [Ordering] criteria. - * - * This stage allows you to order the results of your pipeline. You can specify multiple - * [Ordering] instances to sort by multiple fields in ascending or descending order. If documents - * have the same value for a field used for sorting, the next specified ordering will be used. If - * all orderings result in equal comparison, the documents are considered equal and the order is - * unspecified. - * - * Example: - * ```kotlin - * // Sort books by rating in descending order, and then by title in ascending order for books with the same rating - * firestore.pipeline().collection("books") - * .sort( - * Ordering.of("rating").descending(), - * Ordering.of("title") // Ascending order is the default - * ) - * ``` - * - * @param order The first [Ordering] instance specifying the sorting criteria. - * @param additionalOrders Optional additional [Ordering] instances specifying the sorting - * criteria. - * @return A new [Pipeline] object with this stage appended to the stage list. - */ - -public com.google.firebase.firestore.Pipeline sort(com.google.firebase.firestore.pipeline.Ordering order, com.google.firebase.firestore.pipeline.Ordering... additionalOrders) { throw new RuntimeException("Stub!"); } - -/** - * Filters the documents from previous stages to only include those matching the specified - * [BooleanExpression]. - * - * This stage allows you to apply conditions to the data, similar to a "WHERE" clause in SQL. - * - * You can filter documents based on their field values, using implementations of - * [BooleanExpression], typically including but not limited to: - * - * - field comparators: [Expr.equal], [Expr.lessThan], [Expr.greaterThan], etc. - * - logical operators: [Expr.and], [Expr.or], [Expr.not], etc. - * - advanced functions: [Expr.regexMatch], [Expr.arrayContains], etc. - * - * Example: - * ```kotlin - * firestore.pipeline().collection("books") - * .where( - * and( - * gt("rating", 4.0), // Filter for ratings greater than 4.0 - * field("genre").equal("Science Fiction") // Equivalent to equal("genre", "Science Fiction") - * ) - * ) - * ``` - * - * @param condition The [BooleanExpression] to apply. - * @return A new [Pipeline] object with this stage appended to the stage list. - */ - -public com.google.firebase.firestore.Pipeline where(com.google.firebase.firestore.pipeline.BooleanExpression condition) { throw new RuntimeException("Stub!"); } - -/** - * Skips the first `offset` number of documents from the results of previous stages. - * - * This stage is useful for implementing pagination in your pipelines, allowing you to retrieve - * results in chunks. It is typically used in conjunction with [limit] to control the size of each - * page. - * - * Example: - * ```kotlin - * // Retrieve the second page of 20 results - * firestore.pipeline().collection("books") - * .sort(field("published").descending()) - * .offset(20) // Skip the first 20 results - * .limit(20) // Take the next 20 results - * ``` - * - * @param offset The number of documents to skip. - * @return A new [Pipeline] object with this stage appended to the stage list. - */ - -public com.google.firebase.firestore.Pipeline offset(int offset) { throw new RuntimeException("Stub!"); } - -/** - * Limits the maximum number of documents returned by previous stages to `limit`. - * - * This stage is particularly useful when you want to retrieve a controlled subset of data from a - * potentially large result set. It's often used for: - * - * - **Pagination:** In combination with [offset] to retrieve specific pages of results. - * - **Limiting Data Retrieval:** To prevent excessive data transfer and improve performance, - * especially when dealing with large collections. - * - * Example: - * ```kotlin - * // Limit the results to the top 10 highest-rated books - * firestore.pipeline().collection("books") - * .sort(field("rating").descending()) - * .limit(10) - * ``` - * - * @param limit The maximum number of documents to return. - * @return A new [Pipeline] object with this stage appended to the stage list. - */ - -public com.google.firebase.firestore.Pipeline limit(int limit) { throw new RuntimeException("Stub!"); } - -/** - * Returns a set of distinct values from the inputs to this stage. - * - * This stage runs through the results from previous stages to include only results with unique - * combinations of [Expr] values [Field], [FunctionExpression], etc). - * - * The parameters to this stage are defined using [Selectable] expressions or strings: - * - * - [String]: Name of an existing field - * - [Field]: References an existing document field. - * - [AliasedExpression]: Represents the result of a function with an assigned alias name using - * [Expr.alias] - * - * Example: - * ```kotlin - * // Get a list of unique author names in uppercase and genre combinations. - * firestore.pipeline().collection("books") - * .distinct(toUppercase(field("author")).as("authorName"), field("genre")) - * .select("authorName") - * ``` - * - * @param group The [Selectable] expression to consider when determining distinct value - * combinations. - * @param additionalGroups The [Selectable] expressions to consider when determining distinct - * value combinations or [String]s representing field names. - * @return A new [Pipeline] object with this stage appended to the stage list. - */ - -public com.google.firebase.firestore.Pipeline distinct(com.google.firebase.firestore.pipeline.Selectable group, java.lang.Object... additionalGroups) { throw new RuntimeException("Stub!"); } - -/** - * Returns a set of distinct values from the inputs to this stage. - * - * This stage runs through the results from previous stages to include only results with unique - * combinations of [Expr] values ([Field], [FunctionExpression], etc). - * - * The parameters to this stage are defined using [Selectable] expressions or strings: - * - * - [String]: Name of an existing field - * - [Field]: References an existing document field. - * - [AliasedExpression]: Represents the result of a function with an assigned alias name using - * [Expr.alias] - * - * Example: - * ```kotlin - * // Get a list of unique genres. - * firestore.pipeline().collection("books") - * .distinct("genre") - * ``` - * - * @param groupField The [String] representing field name. - * @param additionalGroups The [Selectable] expressions to consider when determining distinct - * value combinations or [String]s representing field names. - * @return A new [Pipeline] object with this stage appended to the stage list. - */ - -public com.google.firebase.firestore.Pipeline distinct(java.lang.String groupField, java.lang.Object... additionalGroups) { throw new RuntimeException("Stub!"); } - -/** - * Performs aggregation operations on the documents from previous stages. - * - * This stage allows you to calculate aggregate values over a set of documents. You define the - * aggregations to perform using [AliasedAggregate] expressions which are typically results of - * calling [AggregateFunction.alias] on [AggregateFunction] instances. - * - * Example: - * ```kotlin - * // Calculate the average rating and the total number of books - * firestore.pipeline().collection("books") - * .aggregate( - * field("rating").average().as("averageRating"), - * countAll().as("totalBooks") - * ) - * ``` - * - * @param accumulator The first [AliasedAggregate] expression, wrapping an [AggregateFunction] - * with an alias for the accumulated results. - * @param additionalAccumulators The [AliasedAggregate] expressions, each wrapping an - * [AggregateFunction] with an alias for the accumulated results. - * @return A new [Pipeline] object with this stage appended to the stage list. - */ - -public com.google.firebase.firestore.Pipeline aggregate(com.google.firebase.firestore.pipeline.AliasedAggregate accumulator, com.google.firebase.firestore.pipeline.AliasedAggregate... additionalAccumulators) { throw new RuntimeException("Stub!"); } - -/** - * Performs optionally grouped aggregation operations on the documents from previous stages. - * - * This stage allows you to calculate aggregate values over a set of documents, optionally grouped - * by one or more fields or functions. You can specify: - * - * - **Grouping Fields or Expressions:** One or more fields or functions to group the documents - * by. For each distinct combination of values in these fields, a separate group is created. If no - * grouping fields are provided, a single group containing all documents is used. Not specifying - * groups is the same as putting the entire inputs into one group. - * - * - **AggregateFunctions:** One or more accumulation operations to perform within each group. - * These are defined using [AliasedAggregate] expressions, which are typically created by calling - * [AggregateFunction.alias] on [AggregateFunction] instances. Each aggregation calculates a value - * (e.g., sum, average, count) based on the documents within its group. - * - * Example: - * ```kotlin - * // Calculate the average rating for each genre. - * firestore.pipeline().collection("books") - * .aggregate( - * Aggregate - * .withAccumulators(average("rating").as("avg_rating")) - * .withGroups("genre")) - * ``` - * - * @param aggregateStage An [AggregateStage] object that specifies the grouping fields (if any) - * and the aggregation operations to perform. - * @return A new [Pipeline] object with this stage appended to the stage list. - */ - -public com.google.firebase.firestore.Pipeline aggregate(com.google.firebase.firestore.pipeline.AggregateStage aggregateStage) { throw new RuntimeException("Stub!"); } - -/** - * Performs optionally grouped aggregation operations on the documents from previous stages. - * - * This stage allows you to calculate aggregate values over a set of documents, optionally grouped - * by one or more fields or functions. You can specify: - * - * - **Grouping Fields or Expressions:** One or more fields or functions to group the documents - * by. For each distinct combination of values in these fields, a separate group is created. If no - * grouping fields are provided, a single group containing all documents is used. Not specifying - * groups is the same as putting the entire inputs into one group. - * - * - **AggregateFunctions:** One or more accumulation operations to perform within each group. - * These are defined using [AliasedAggregate] expressions, which are typically created by calling - * [AggregateFunction.alias] on [AggregateFunction] instances. Each aggregation calculates a value - * (e.g., sum, average, count) based on the documents within its group. - * - * @param aggregateStage An [AggregateStage] object that specifies the grouping fields (if any) - * and the aggregation operations to perform. - * @param options The [AggregateOptions] to use when performing the aggregation. - * @return A new [Pipeline] object with this stage appended to the stage list. - */ - -public com.google.firebase.firestore.Pipeline aggregate(com.google.firebase.firestore.pipeline.AggregateStage aggregateStage, com.google.firebase.firestore.pipeline.AggregateOptions options) { throw new RuntimeException("Stub!"); } - -/** - * Performs a vector similarity search, ordering the result set by most similar to least similar, - * and returning the full set in the order of similarity. - * - * @param vectorField A [String] specifying the vector field to search on. - * @param vectorValue The [DoubleArray] that is used to measure the distance from [vectorField] - * values in the documents. - * @param distanceMeasure specifies what type of distance is calculated when performing the - * search. - * @return A new [Pipeline] object with this stage appended to the stage list. - */ - -public com.google.firebase.firestore.Pipeline findNearest(java.lang.String vectorField, double[] vectorValue, com.google.firebase.firestore.pipeline.FindNearestStage.DistanceMeasure distanceMeasure) { throw new RuntimeException("Stub!"); } - -/** - * Performs a vector similarity search, ordering the result set by most similar to least similar, - * and returning the full set in the order of similarity. - * - * @param vectorField A [Field] that contains vector to search on. - * @param vectorValue The [DoubleArray] that is used to measure the distance from [vectorField] - * values in the documents. - * @param distanceMeasure specifies what type of distance is calculated. when performing the - * search. - * @return A new [Pipeline] object with this stage appended to the stage list. - */ - -public com.google.firebase.firestore.Pipeline findNearest(com.google.firebase.firestore.pipeline.Field vectorField, double[] vectorValue, com.google.firebase.firestore.pipeline.FindNearestStage.DistanceMeasure distanceMeasure) { throw new RuntimeException("Stub!"); } - -/** - * Performs a vector similarity search, ordering the result set by most similar to least similar, - * and returning the first N documents (specified by [FindNearestOptions.withLimit]) in the result - * set. - * - * Example: - * ```kotlin - * // Find books with similar "topicVectors" to the given targetVector - * firestore.pipeline().collection("books") - * .findNearest("topicVectors", targetVector, FindNearest.DistanceMeasure.COSINE, - * FindNearestOptions() - * .withLimit(10) - * .withDistanceField("distance")) - * ``` - * - * @param vectorField A field name that contains vector to search on. - * @param vectorValue The [Expression] that should evaluate to a vector used to measure the - * distance from [vectorField] values in the documents. - * @param distanceMeasure specifies what type of distance is calculated when performing the - * search. - * @param options The [FindNearestOptions] to use when performing the search. - * @return A new [Pipeline] object with this stage appended to the stage list. - */ - -public com.google.firebase.firestore.Pipeline findNearest(java.lang.String vectorField, com.google.firebase.firestore.pipeline.Expression vectorValue, com.google.firebase.firestore.pipeline.FindNearestStage.DistanceMeasure distanceMeasure, com.google.firebase.firestore.pipeline.FindNearestOptions options) { throw new RuntimeException("Stub!"); } - -/** - * Fully overwrites all fields in a document with those coming from a nested map. - * - * This stage allows you to emit a map value as a document. Each key of the map becomes a field on - * the document that contains the corresponding value. - * - * Example: - * ```kotlin - * // Input. - * // { - * // "name": "John Doe Jr.", - * // "parents": { - * // "father": "John Doe Sr.", - * // "mother": "Jane Doe" - * // } - * - * // Emit parents as document. - * firestore.pipeline().collection("people").replaceWith("parents") - * - * // Output - * // { - * // "father": "John Doe Sr.", - * // "mother": "Jane Doe" - * // } - * ``` - * - * @param field The [String] specifying the field name containing the nested map. - * @return A new [Pipeline] object with this stage appended to the stage list. - */ - -public com.google.firebase.firestore.Pipeline replaceWith(java.lang.String field) { throw new RuntimeException("Stub!"); } - -/** - * Fully overwrites all fields in a document with those coming from a nested map. - * - * This stage allows you to emit a map value as a document. Each key of the map becomes a field on - * the document that contains the corresponding value. - * - * Example: - * ```kotlin - * // Input. - * // { - * // "name": "John Doe Jr.", - * // "parents": { - * // "father": "John Doe Sr.", - * // "mother": "Jane Doe" - * // } - * - * // Emit parents as document. - * firestore.pipeline().collection("people").replaceWith(field("parents")) - * - * // Output - * // { - * // "father": "John Doe Sr.", - * // "mother": "Jane Doe" - * // } - * ``` - * - * @param mapValue The [Expression] or [Field] containing the nested map. - * @return A new [Pipeline] object with this stage appended to the stage list. - */ - -public com.google.firebase.firestore.Pipeline replaceWith(com.google.firebase.firestore.pipeline.Expression mapValue) { throw new RuntimeException("Stub!"); } - -/** - * Performs a pseudo-random sampling of the input documents. - * - * The [documents] parameter represents the target number of documents to produce and must be a - * non-negative integer value. If the previous stage produces less than size documents, the entire - * previous results are returned. If the previous stage produces more than size, this outputs a - * sample of exactly size entries where any sample is equally likely. - * - * Example: - * ```kotlin - * // Sample 10 books, if available. - * firestore.pipeline().collection("books") - * .sample(10) - * ``` - * - * @param documents The number of documents to emit. - * @return A new [Pipeline] object with this stage appended to the stage list. - */ - -public com.google.firebase.firestore.Pipeline sample(int documents) { throw new RuntimeException("Stub!"); } - -/** - * Performs a pseudo-random sampling of the input documents. - * - * Examples: - * ```kotlin - * // Sample 10 books, if available. - * firestore.pipeline().collection("books") - * .sample(Sample.withDocLimit(10)) - * - * // Sample 50% of books. - * firestore.pipeline().collection("books") - * .sample(Sample.withPercentage(0.5)) - * ``` - * - * @param sample An [SampleStage] object that specifies how sampling is performed. - * @return A new [Pipeline] object with this stage appended to the stage list. - */ - -public com.google.firebase.firestore.Pipeline sample(com.google.firebase.firestore.pipeline.SampleStage sample) { throw new RuntimeException("Stub!"); } - -/** - * Performs union of all documents from two pipelines, including duplicates. - * - * This stage will pass through documents from previous stage, and also pass through documents - * from previous stage of the `other` Pipeline given in parameter. The order of documents emitted - * from this stage is undefined. - * - * Example: - * ```kotlin - * // Emit documents from books collection and magazines collection. - * firestore.pipeline().collection("books") - * .union(firestore.pipeline().collection("magazines")) - * ``` - * - * @param other The other [Pipeline] that is part of union. - * @return A new [Pipeline] object with this stage appended to the stage list. - */ - -public com.google.firebase.firestore.Pipeline union(com.google.firebase.firestore.Pipeline other) { throw new RuntimeException("Stub!"); } - -/** - * Takes a specified array from the input documents and outputs a document for each element with - * the element stored in a field with name specified by the alias. - * - * For each document emitted by the prior stage, this stage will emit zero or more augmented - * documents. The input array found in the previous stage document field specified by the - * [arrayField] parameter, will for each element of the input array produce an augmented document. - * The element of the input array will be stored in a field with name specified by [alias] - * parameter on the augmented document. - * - * Example: - * ```kotlin - * // Input: - * // { "title": "The Hitchhiker's Guide to the Galaxy", "tags": [ "comedy", "space", "adventure" ], ... } - * - * // Emit a book document for each tag of the book. - * firestore.pipeline().collection("books") - * .unnest("tags", "tag") - * - * // Output: - * // { "title": "The Hitchhiker's Guide to the Galaxy", "tag": "comedy", ... } - * // { "title": "The Hitchhiker's Guide to the Galaxy", "tag": "space", ... } - * // { "title": "The Hitchhiker's Guide to the Galaxy", "tag": "adventure", ... } - * ``` - * - * @param arrayField The name of the field containing the array. - * @param alias The name of field to store emitted element of array. - * @return A new [Pipeline] object with this stage appended to the stage list. - */ - -public com.google.firebase.firestore.Pipeline unnest(java.lang.String arrayField, java.lang.String alias) { throw new RuntimeException("Stub!"); } - -/** - * Takes a specified array from the input documents and outputs a document for each element with - * the element stored in a field with name specified by the alias. - * - * For each document emitted by the prior stage, this stage will emit zero or more augmented - * documents. The input array is found in parameter [arrayWithAlias], which can be an [Expr] with - * an alias specified via [Expr.alias], or a [Field] that can also have alias specified. For each - * element of the input array, an augmented document will be produced. The element of input array - * will be stored in a field with name specified by the alias of the [arrayWithAlias] parameter. - * If the [arrayWithAlias] is a [Field] with no alias, then the original array field will be - * replaced with the individual element. - * - * @param arrayWithAlias The input array with field alias to store output element of array. - * @return A new [Pipeline] object with this stage appended to the stage list. - */ - -public com.google.firebase.firestore.Pipeline unnest(com.google.firebase.firestore.pipeline.Selectable arrayWithAlias) { throw new RuntimeException("Stub!"); } - -/** - * Takes a specified array from the input documents and outputs a document for each element with - * the element stored in a field with name specified by the alias. - * - * For each document emitted by the prior stage, this stage will emit zero or more augmented - * documents. The input array is found in parameter [arrayWithAlias], which can be an [Expr] with - * an alias specified via [Expr.alias], or a [Field] that can also have alias specified. For each - * element of the input array, an augmented document will be produced. The element of input array - * will be stored in a field with name specified by the alias of the [arrayWithAlias] parameter. - * If the [arrayWithAlias] is a [Field] with no alias, then the original array field will be - * replaced with the individual element. - * - * Example: - * ```kotlin - * // Input: - * // { "title": "The Hitchhiker's Guide to the Galaxy", "tags": [ "comedy", "space", "adventure" ], ... } - * - * // Emit a book document for each tag of the book. - * firestore.pipeline().collection("books") - * .unnest("tags", "tag", UnnestOptions().withIndexField("tagIndex")) - * - * // Output: - * // { "title": "The Hitchhiker's Guide to the Galaxy", "tagIndex": 0, "tag": "comedy", ... } - * // { "title": "The Hitchhiker's Guide to the Galaxy", "tagIndex": 1, "tag": "space", ... } - * // { "title": "The Hitchhiker's Guide to the Galaxy", "tagIndex": 2, "tag": "adventure", ... } - * ``` - * - * @param arrayWithAlias The input array with field alias to store output element of array. - * @param options The [UnnestOptions] to use when performing the unnest. - * @return A new [Pipeline] object with this stage appended to the stage list. - */ - -public com.google.firebase.firestore.Pipeline unnest(com.google.firebase.firestore.pipeline.Selectable arrayWithAlias, com.google.firebase.firestore.pipeline.UnnestOptions options) { throw new RuntimeException("Stub!"); } - -/** - * Takes a specified array from the input documents and outputs a document for each element with - * the element stored in a field with name specified by the alias. - * - * For each document emitted by the prior stage, this stage will emit zero or more augmented - * documents. The input array specified in the [unnestStage] parameter will for each element of - * the input array produce an augmented document. The element of the input array will be stored in - * a field with a name specified by the [unnestStage] parameter. - * - * Optionally, an index field can also be added to emitted documents. See [UnnestStage] for - * further information. - * - * @param unnestStage An [UnnestStage] object that specifies the search parameters. - * @return A new [Pipeline] object with this stage appended to the stage list. - */ - -public com.google.firebase.firestore.Pipeline unnest(com.google.firebase.firestore.pipeline.UnnestStage unnestStage) { throw new RuntimeException("Stub!"); } - -/** - * Defines one or more variables in the pipeline's scope. `define` is used to bind a value to a - * variable for internal reuse within the pipeline body (accessed via the `variable()` function). - * - * This stage is particularly useful for passing values from an outer pipeline into a subquery, or - * for declaring reusable intermediate calculations that can be referenced multiple times in later - * parts of the pipeline via `variable()`. - * - * Each variable is defined using an [AliasedExpression], which pairs an expression with a name - * (alias). The expression can be a simple constant, a field reference, or a function evaluation - * (such as a mathematical operation). - * - * Example: - * ```kotlin - * firestore.pipeline().collection("products") - * .define(field("category").alias("productCategory")) - * .addFields( - * firestore.pipeline().collection("categories") - * .where(field("name").equal(variable("productCategory"))) - * .select(field("description")) - * .toScalarExpression().alias("categoryDescription") - * ) - * ``` - * - * @param aliasedExpression The first variable to define, specified as an [AliasedExpression]. - * @param additionalExpressions Optional additional variables to define, specified as - * [AliasedExpression]s. - * @return A new [Pipeline] object with this stage appended to the stage list. - */ - -public com.google.firebase.firestore.Pipeline define(com.google.firebase.firestore.pipeline.AliasedExpression aliasedExpression, com.google.firebase.firestore.pipeline.AliasedExpression... additionalExpressions) { throw new RuntimeException("Stub!"); } - -/** - * Converts this Pipeline into an expression that evaluates to an array of results. - * - * **Result Unwrapping:** - * - If the items have a single field, their values are unwrapped and returned directly in the - * array. - * - If the items have multiple fields, they are returned as Maps in the array. - * - * Example: - * ```kotlin - * // Get a list of reviewers for each book - * db.pipeline().collection("books") - * .define(field("id").alias("book_id")) - * .addFields( - * db.pipeline().collection("reviews") - * .where(field("book_id").equal(variable("book_id"))) - * .select(field("reviewer")) - * .toArrayExpression() - * .alias("reviewers")) - * ``` - * - * Output: - * ```json - * [ - * { - * "id": "1", - * "title": "1984", - * "reviewers": ["Alice", "Bob"] - * } - * ] - * ``` - * - * Example (Multiple Fields): - * ```kotlin - * // Get a list of reviews (reviewer and rating) for each book - * db.pipeline().collection("books") - * .define(field("id").alias("book_id")) - * .addFields( - * db.pipeline().collection("reviews") - * .where(field("book_id").equal(variable("book_id"))) - * .select(field("reviewer"), field("rating")) - * .toArrayExpression() - * .alias("reviews")) - * ``` - * - * *When the subquery produces multiple fields, they are kept as objects in the array:* - * - * Output: - * ```json - * [ - * { - * "id": "1", - * "title": "1984", - * "reviews": [ - * { "reviewer": "Alice", "rating": 5 }, - * { "reviewer": "Bob", "rating": 4 } - * ] - * } - * ] - * ``` - * - * @return An [Expression] that executes this pipeline and returns the results as a list. - */ - -public com.google.firebase.firestore.pipeline.Expression toArrayExpression() { throw new RuntimeException("Stub!"); } - -/** - * Converts this Pipeline into an expression that evaluates to a single scalar result. - * - * **Runtime Validation:** The runtime validates that the result set contains zero or one item. If - * zero items, it evaluates to `null`. - * - * **Result Unwrapping:** If the result contains exactly one item: - * - If the item has a single field, its value is unwrapped and returned directly. - * - If the item has multiple fields, they are returned as a Map. - * - * Example: - * ```kotlin - * // Calculate average rating for a restaurant - * db.pipeline().collection("restaurants") - * .define(field("id").alias("rid")) - * .addFields( - * db.pipeline().collection("reviews") - * .where(field("restaurant_id").equal(variable("rid"))) - * .aggregate(AggregateFunction.average("rating").alias("avg")) - * // Unwraps the single "avg" field to a scalar double - * .toScalarExpression().alias("average_rating") - * ) - * ``` - * - * Output: - * ```json - * { - * "name": "The Burger Joint", - * "average_rating": 4.5 - * } - * ``` - * - * Example (Multiple Fields): - * ```kotlin - * // Calculate average rating AND count for a restaurant - * db.pipeline().collection("restaurants") - * .define(field("id").alias("rid")) - * .addFields( - * db.pipeline().collection("reviews") - * .where(field("restaurant_id").equal(variable("rid"))) - * .aggregate( - * AggregateFunction.average("rating").alias("avg"), - * AggregateFunction.count().alias("count") - * ) - * // Returns a Map with "avg" and "count" fields - * .toScalarExpression().alias("stats") - * ) - * ``` - * - * Output: - * ```json - * { - * "name": "The Burger Joint", - * "stats": { - * "avg": 4.5, - * "count": 100 - * } - * } - * ``` - * - * @return An [Expression] representing the scalar result. - */ - -public com.google.firebase.firestore.pipeline.Expression toScalarExpression() { throw new RuntimeException("Stub!"); } - -/** - * Add a search stage to the Pipeline. - * - * Note: This must be the first stage of the pipeline. - * - * A limited set of expressions are supported in the search stage. - * - * @example - * ```kotlin - * db.pipeline().collection("restaurants").search( - * SearchStage( - * query = documentMatches("waffles OR pancakes"), - * sort = arrayOf(score().descending()) - * ) - * ) - * ``` - * - * @param searchStage An object that specifies how search is performed. - * @return A new `Pipeline` object with this stage appended to the stage list. - */ - -public com.google.firebase.firestore.Pipeline search(com.google.firebase.firestore.pipeline.SearchStage searchStage) { throw new RuntimeException("Stub!"); } -@SuppressWarnings({"unchecked", "deprecation", "all"}) -public static final class ExecuteOptions extends com.google.firebase.firestore.pipeline.AbstractOptions { - -public ExecuteOptions() { super(null); throw new RuntimeException("Stub!"); } - -public com.google.firebase.firestore.Pipeline.ExecuteOptions self(com.google.firebase.firestore.pipeline.InternalOptions options) { throw new RuntimeException("Stub!"); } - -public com.google.firebase.firestore.Pipeline.ExecuteOptions withIndexMode(com.google.firebase.firestore.Pipeline.ExecuteOptions.IndexMode indexMode) { throw new RuntimeException("Stub!"); } -@SuppressWarnings({"unchecked", "deprecation", "all"}) -public static final class IndexMode { - -IndexMode() { throw new RuntimeException("Stub!"); } - -public static final com.google.firebase.firestore.Pipeline.ExecuteOptions.IndexMode.Companion Companion; -static { Companion = null; } - -public static final com.google.firebase.firestore.Pipeline.ExecuteOptions.IndexMode RECOMMENDED; -static { RECOMMENDED = null; } -@SuppressWarnings({"unchecked", "deprecation", "all"}) -public static final class Companion { - -Companion() { throw new RuntimeException("Stub!"); } -} - -} - -} - -/** - * A `Snapshot` contains the results of a pipeline execution. It can be iterated to retrieve the - * individual `PipelineResult` objects. - */ - -@SuppressWarnings({"unchecked", "deprecation", "all"}) -public static final class Snapshot implements java.lang.Iterable, kotlin.jvm.internal.markers.KMappedMarker { - -Snapshot() { throw new RuntimeException("Stub!"); } - -/** The time at which the pipeline producing this result is executed. */ - -public com.google.firebase.Timestamp getExecutionTime() { throw new RuntimeException("Stub!"); } - -/** List of all the results */ - -public java.util.List getResults() { throw new RuntimeException("Stub!"); } - -public java.util.Iterator iterator() { throw new RuntimeException("Stub!"); } - -public java.lang.String toString() { throw new RuntimeException("Stub!"); } - -public boolean equals(java.lang.Object other) { throw new RuntimeException("Stub!"); } - -public int hashCode() { throw new RuntimeException("Stub!"); } -} - -} - - - -// File: PipelineResult.java -// Copyright 2025 Google LLC -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file 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. -// Validate document path by converting to DocumentReference -package com.google.firebase.firestore; - - -/** - * Represents the results of a Pipeline query, including the data and metadata. It is usually - * accessed via [Pipeline.Snapshot]. - */ - -@SuppressWarnings({"unchecked", "deprecation", "all"}) -public final class PipelineResult { - -PipelineResult() { throw new RuntimeException("Stub!"); } - -/** The time the document was created. Null if this result is not a document. */ - -public com.google.firebase.Timestamp getCreateTime() { throw new RuntimeException("Stub!"); } - -/** - * The time the document was last updated (at the time the snapshot was generated). Null if this - * result is not a document. - */ - -public com.google.firebase.Timestamp getUpdateTime() { throw new RuntimeException("Stub!"); } - -/** - * The reference to the document, if the query returns the document id for a document. The name - * field will be returned by default if querying a document. - * - * Document ids will not be returned if certain pipeline stages omit the document id. For example, - * [Pipeline.select], [Pipeline.removeFields] and [Pipeline.aggregate] can omit the document id. - * - * @return [DocumentReference] Reference to the document, if applicable. - */ - -public com.google.firebase.firestore.DocumentReference getRef() { throw new RuntimeException("Stub!"); } - -/** - * Returns the ID of the document represented by this result. Returns null if this result is not - * corresponding to a Firestore document. - * - * @return ID of document, if applicable. - */ - -public java.lang.String getId() { throw new RuntimeException("Stub!"); } - -/** - * Retrieves all fields in the result as an object map. - * - * @return Map of field names to objects. - */ - -public java.util.Map getData() { throw new RuntimeException("Stub!"); } - -/** - * Retrieves the field specified by [field]. - * - * @param field The field path (e.g. "foo" or "foo.bar") to a specific field. - * @return The data at the specified field location or null if no such field exists. - */ - -public java.lang.Object get(java.lang.String field) { throw new RuntimeException("Stub!"); } - -/** - * Retrieves the field specified by [fieldPath]. - * - * @param fieldPath The field path to a specific field. - * @return The data at the specified field location or null if no such field exists. - */ - -public java.lang.Object get(com.google.firebase.firestore.FieldPath fieldPath) { throw new RuntimeException("Stub!"); } - -public java.lang.String toString() { throw new RuntimeException("Stub!"); } - -public boolean equals(java.lang.Object other) { throw new RuntimeException("Stub!"); } - -public int hashCode() { throw new RuntimeException("Stub!"); } -} - - - -// File: PipelineSource.java -// Copyright 2025 Google LLC -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file 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. -// Validate document path by converting to DocumentReference -package com.google.firebase.firestore; - - -/** Start of a Firestore Pipeline */ - -@SuppressWarnings({"unchecked", "deprecation", "all"}) -public final class PipelineSource { - -PipelineSource() { throw new RuntimeException("Stub!"); } - -/** - * Convert the given Query into an equivalent Pipeline. - * - * @param query A Query to be converted into a Pipeline. - * @return A new [Pipeline] object that is equivalent to [query] - * @throws [IllegalArgumentException] Thrown if the [query] provided targets a different project - * or database than the pipeline. - */ - -public com.google.firebase.firestore.Pipeline createFrom(com.google.firebase.firestore.Query query) { throw new RuntimeException("Stub!"); } - -/** - * Convert the given Aggregate Query into an equivalent Pipeline. - * - * @param aggregateQuery An Aggregate Query to be converted into a Pipeline. - * @return A new [Pipeline] object that is equivalent to [aggregateQuery] - * @throws [IllegalArgumentException] Thrown if the [aggregateQuery] provided targets a different - * project or database than the pipeline. - */ - -public com.google.firebase.firestore.Pipeline createFrom(com.google.firebase.firestore.AggregateQuery aggregateQuery) { throw new RuntimeException("Stub!"); } - -/** - * Set the pipeline's source to the collection specified by the given path. - * - * @param path A path to a collection that will be the source of this pipeline. - * @return A new [Pipeline] object with documents from target collection. - */ - -public com.google.firebase.firestore.Pipeline collection(java.lang.String path) { throw new RuntimeException("Stub!"); } - -/** - * Set the pipeline's source to the collection specified by the given [CollectionReference]. - * - * @param ref A [CollectionReference] for a collection that will be the source of this pipeline. - * @return A new [Pipeline] object with documents from target collection. - * @throws [IllegalArgumentException] Thrown if the [ref] provided targets a different project or - * database than the pipeline. - */ - -public com.google.firebase.firestore.Pipeline collection(com.google.firebase.firestore.CollectionReference ref) { throw new RuntimeException("Stub!"); } - -/** - * Set the pipeline's source to the collection specified by the given [CollectionReference]. - * - * @param ref A [CollectionReference] for a collection that will be the source of this pipeline. - * @param options [CollectionSourceOptions] for the collection. - * @return A new [Pipeline] object with documents from target collection. - * @throws [IllegalArgumentException] Thrown if the [ref] provided targets a different project or - * database than the pipeline. - */ - -public com.google.firebase.firestore.Pipeline collection(com.google.firebase.firestore.CollectionReference ref, com.google.firebase.firestore.pipeline.CollectionSourceOptions options) { throw new RuntimeException("Stub!"); } - -/** - * Set the pipeline's source to the collection group with the given id. - * - * @param collectionId The id of a collection group that will be the source of this pipeline. - * @return A new [Pipeline] object with documents from target collection group. - */ - -public com.google.firebase.firestore.Pipeline collectionGroup(java.lang.String collectionId) { throw new RuntimeException("Stub!"); } - -/** - * Set the pipeline's source to the collection group with the given id. - * - * @param collectionId The id of a collection group that will be the source of this pipeline. - * @param options [CollectionGroupOptions] for the collection group. - * @return A new [Pipeline] object with documents from target collection group. - */ - -public com.google.firebase.firestore.Pipeline collectionGroup(java.lang.String collectionId, com.google.firebase.firestore.pipeline.CollectionGroupOptions options) { throw new RuntimeException("Stub!"); } - -/** - * Set the pipeline's source to be all documents in this database. - * - * @return A new [Pipeline] object with all documents in this database. - */ - -public com.google.firebase.firestore.Pipeline database() { throw new RuntimeException("Stub!"); } - -/** - * Set the pipeline's source to the documents specified by the given paths. - * - * @param documents Paths specifying the individual documents that will be the source of this - * pipeline. - * @return A new [Pipeline] object with [documents]. - */ - -public com.google.firebase.firestore.Pipeline documents(java.lang.String... documents) { throw new RuntimeException("Stub!"); } - -/** - * Set the pipeline's source to the documents specified by the given DocumentReferences. - * - * @param documents DocumentReferences specifying the individual documents that will be the source - * of this pipeline. - * @return Pipeline with [documents]. - * @throws [IllegalArgumentException] Thrown if the [documents] provided targets a different - * project or database than the pipeline. - */ - -public com.google.firebase.firestore.Pipeline documents(com.google.firebase.firestore.DocumentReference... documents) { throw new RuntimeException("Stub!"); } - -/** - * Initializes a pipeline scoped to a subcollection. - * - * This method allows you to start a new pipeline that operates on a subcollection of the - * current document. It is intended to be used as a subquery. - * - * **Note:** A pipeline created with `subcollection` cannot be executed directly. It must be - * used within a parent pipeline. - * - * Example: - * ```kotlin - * firestore.pipeline().collection("books") - * .addFields( - * PipelineSource.subcollection("reviews") - * .aggregate(AggregateFunction.average("rating").as("avg_rating")) - * .toScalarExpression().as("average_rating")) - * ``` - * - * @param path The path of the subcollection. - * @return A new [Pipeline] instance scoped to the subcollection. - */ - -public static com.google.firebase.firestore.Pipeline subcollection(java.lang.String path) { throw new RuntimeException("Stub!"); } - -/** - * Creates a pipeline that processes the documents in the specified subcollection of the current - * document. - * - * Example: - * ```kotlin - * firestore.pipeline().collection("books") - * .addFields( - * PipelineSource.subcollection(SubcollectionSource.of("reviews")) - * .aggregate(AggregateFunction.average("rating").as("avg_rating")) - * .toScalarExpression().as("average_rating")) - * ``` - * - * @param source The subcollection that will be the source of this pipeline. - * @return A new [Pipeline] scoped to the subcollection. - */ - -public static com.google.firebase.firestore.Pipeline subcollection(com.google.firebase.firestore.pipeline.SubcollectionSource source) { throw new RuntimeException("Stub!"); } - -public static final com.google.firebase.firestore.PipelineSource.Companion Companion; -static { Companion = null; } -@SuppressWarnings({"unchecked", "deprecation", "all"}) -public static final class Companion { - -Companion() { throw new RuntimeException("Stub!"); } - -/** - * Initializes a pipeline scoped to a subcollection. - * - * This method allows you to start a new pipeline that operates on a subcollection of the - * current document. It is intended to be used as a subquery. - * - * **Note:** A pipeline created with `subcollection` cannot be executed directly. It must be - * used within a parent pipeline. - * - * Example: - * ```kotlin - * firestore.pipeline().collection("books") - * .addFields( - * PipelineSource.subcollection("reviews") - * .aggregate(AggregateFunction.average("rating").as("avg_rating")) - * .toScalarExpression().as("average_rating")) - * ``` - * - * @param path The path of the subcollection. - * @return A new [Pipeline] instance scoped to the subcollection. - */ - -public com.google.firebase.firestore.Pipeline subcollection(java.lang.String path) { throw new RuntimeException("Stub!"); } - -/** - * Creates a pipeline that processes the documents in the specified subcollection of the current - * document. - * - * Example: - * ```kotlin - * firestore.pipeline().collection("books") - * .addFields( - * PipelineSource.subcollection(SubcollectionSource.of("reviews")) - * .aggregate(AggregateFunction.average("rating").as("avg_rating")) - * .toScalarExpression().as("average_rating")) - * ``` - * - * @param source The subcollection that will be the source of this pipeline. - * @return A new [Pipeline] scoped to the subcollection. - */ - -public com.google.firebase.firestore.Pipeline subcollection(com.google.firebase.firestore.pipeline.SubcollectionSource source) { throw new RuntimeException("Stub!"); } -} - -} - - - diff --git a/plugins/src/main/java/com/google/firebase/gradle/plugins/BaseFirebaseLibraryPlugin.kt b/plugins/src/main/java/com/google/firebase/gradle/plugins/BaseFirebaseLibraryPlugin.kt index a3f73965231..7027d14b313 100644 --- a/plugins/src/main/java/com/google/firebase/gradle/plugins/BaseFirebaseLibraryPlugin.kt +++ b/plugins/src/main/java/com/google/firebase/gradle/plugins/BaseFirebaseLibraryPlugin.kt @@ -178,12 +178,23 @@ abstract class BaseFirebaseLibraryPlugin : Plugin { } protected fun getGenerateApiTxt(project: Project, srcDirs: ConfigurableFileCollection) = - project.tasks.register("generateApiTxtFile") { - sources.from(project.provider { srcDirs }) - apiTxtFile.set(project.file("api.txt")) - baselineFile.set(project.file("baseline.txt")) - updateBaseline.set(project.hasProperty("updateBaseline")) - } + project.tasks + .register("generateApiTxtFile") { + sources.from(project.provider { srcDirs }) + apiTxtFile.set(project.file("api.txt")) + baselineFile.set(project.file("baseline.txt")) + updateBaseline.set(project.hasProperty("updateBaseline")) + } + .also { taskProvider -> + if (project.name == "firebase-firestore") { + project.tasks.withType(org.gradle.api.tasks.bundling.Jar::class.java).configureEach { + if (name == "sourceReleaseJar") { + from(project.layout.buildDirectory.dir("agent-docs")) + dependsOn(taskProvider) + } + } + } + } protected fun getDocStubs(project: Project, srcDirs: ConfigurableFileCollection) = project.tasks.register("docStubs") { diff --git a/plugins/src/main/java/com/google/firebase/gradle/plugins/Metalava.kt b/plugins/src/main/java/com/google/firebase/gradle/plugins/Metalava.kt index 67361aeb63e..59155b1c62d 100644 --- a/plugins/src/main/java/com/google/firebase/gradle/plugins/Metalava.kt +++ b/plugins/src/main/java/com/google/firebase/gradle/plugins/Metalava.kt @@ -119,8 +119,11 @@ abstract class GenerateApiTxtTask @Inject constructor(private val execOperations @get:org.gradle.api.tasks.Optional @get:org.gradle.api.tasks.OutputDirectory - val assetDocsDir: File? - get() = if (project.name == "firebase-firestore") project.file("src/main/assets") else null + val agentDocsDir: File? + get() = + if (project.name == "firebase-firestore") + project.file("${project.layout.buildDirectory.get().asFile}/agent-docs") + else null @get:Input abstract val updateBaseline: Property @@ -160,7 +163,7 @@ abstract class GenerateApiTxtTask @Inject constructor(private val execOperations val classPathString = classPathList.joinToString(":") val fsSourcePath = project.file("src/main/java").absolutePath - generateAssetDocs( + generateAgentDocs( targetFiles = listOf(project.file("src/main/java/com/google/firebase/firestore/Pipeline.kt")), stubDirName = "doc-stubs-pipeline", @@ -169,7 +172,7 @@ abstract class GenerateApiTxtTask @Inject constructor(private val execOperations sourcePath = fsSourcePath, ) - generateAssetDocs( + generateAgentDocs( targetFiles = listOf( project.file("src/main/java/com/google/firebase/firestore/pipeline/expressions.kt"), @@ -183,7 +186,7 @@ abstract class GenerateApiTxtTask @Inject constructor(private val execOperations } } - private fun generateAssetDocs( + private fun generateAgentDocs( targetFiles: List, stubDirName: String, outputFileName: String, @@ -209,8 +212,9 @@ abstract class GenerateApiTxtTask @Inject constructor(private val execOperations ignoreFailure = false, ) - val assetsDocsFile = project.file("src/main/assets/$outputFileName") - project.file("src/main/assets").mkdirs() + val agentDocsFile = + project.file("${project.layout.buildDirectory.get().asFile}/agent-docs/$outputFileName") + project.file("${project.layout.buildDirectory.get().asFile}/agent-docs").mkdirs() val content = buildString { docStubsDir .walkTopDown() @@ -222,7 +226,7 @@ abstract class GenerateApiTxtTask @Inject constructor(private val execOperations append("\n\n") } } - assetsDocsFile.writeText(content) + agentDocsFile.writeText(content) } }