@ahoo-wang/wow-client 9.2.0-rc.0

package/dist/dsl/filter/operator.d.cts

@@ -0,0 +1,113 @@
+/**
+ * Discriminator sent as the `op` property of every filter expression. The
+ * values match the server-side `FilterOperator` enum.
+ */
+export declare enum FilterOperator {
+    MATCH_ALL = "MATCH_ALL",
+    MATCH_NONE = "MATCH_NONE",
+    ID = "ID",
+    IDS = "IDS",
+    AGGREGATE_ID = "AGGREGATE_ID",
+    AGGREGATE_IDS = "AGGREGATE_IDS",
+    TENANT_ID = "TENANT_ID",
+    OWNER_ID = "OWNER_ID",
+    SPACE_ID = "SPACE_ID",
+    AND = "AND",
+    OR = "OR",
+    NOR = "NOR",
+    EQ = "EQ",
+    NE = "NE",
+    GT = "GT",
+    GTE = "GTE",
+    LT = "LT",
+    LTE = "LTE",
+    CONTAINS = "CONTAINS",
+    STARTS_WITH = "STARTS_WITH",
+    ENDS_WITH = "ENDS_WITH",
+    IN = "IN",
+    NOT_IN = "NOT_IN",
+    BETWEEN = "BETWEEN",
+    CONTAINS_ALL = "CONTAINS_ALL",
+    IS_EMPTY = "IS_EMPTY",
+    IS_EMPTY_STRING = "IS_EMPTY_STRING",
+    IS_NOT_EMPTY_STRING = "IS_NOT_EMPTY_STRING",
+    IS_NULL = "IS_NULL",
+    IS_NOT_NULL = "IS_NOT_NULL",
+    EXISTS = "EXISTS",
+    NOT_EXISTS = "NOT_EXISTS",
+    DELETION = "DELETION",
+    ELEMENT_MATCH = "ELEMENT_MATCH",
+    SEARCH = "SEARCH",
+    TODAY = "TODAY",
+    BEFORE_TODAY = "BEFORE_TODAY",
+    TOMORROW = "TOMORROW",
+    THIS_WEEK = "THIS_WEEK",
+    NEXT_WEEK = "NEXT_WEEK",
+    LAST_WEEK = "LAST_WEEK",
+    THIS_MONTH = "THIS_MONTH",
+    LAST_MONTH = "LAST_MONTH",
+    YESTERDAY = "YESTERDAY",
+    NEXT_MONTH = "NEXT_MONTH",
+    LAST_YEAR = "LAST_YEAR",
+    THIS_YEAR = "THIS_YEAR",
+    NEXT_YEAR = "NEXT_YEAR",
+    RECENT_DAYS = "RECENT_DAYS",
+    EARLIER_DAYS = "EARLIER_DAYS",
+    /**
+     * The field is strictly before the server's `now + offset`. Needs a Wow
+     * server of 9.2.0 or later.
+     */
+    BEFORE_NOW = "BEFORE_NOW",
+    /**
+     * The field is strictly after the server's `now + offset`. Needs a Wow
+     * server of 9.2.0 or later.
+     */
+    AFTER_NOW = "AFTER_NOW",
+    /**
+     * A computed expression, such as the hours between two time fields,
+     * compared with a number. Evaluated per record, so expensive; a record
+     * whose expression has no value never matches. Needs a Wow server of
+     * 9.2.0 or later.
+     */
+    EXPRESSION = "EXPRESSION"
+}
+/**
+ * Case handling for `CONTAINS`, `STARTS_WITH` and `ENDS_WITH`.
+ */
+export declare enum StringComparison {
+    /**
+     * Characters must match exactly. The default.
+     */
+    CASE_SENSITIVE = "CASE_SENSITIVE",
+    /**
+     * Ignores case. Backends may execute this more expensively.
+     */
+    CASE_INSENSITIVE = "CASE_INSENSITIVE"
+}
+/**
+ * Matching mode of a full-text `SEARCH` filter.
+ */
+export declare enum SearchMode {
+    /**
+     * Analyzed terms match independently; they need not appear together. The
+     * default.
+     */
+    TERMS = "TERMS",
+    /**
+     * Analyzed terms must appear in order and at adjacent positions.
+     */
+    PHRASE = "PHRASE"
+}
+/**
+ * Unit of a numeric epoch time field targeted by a relative time filter.
+ * Ignored when `datePattern` is set.
+ */
+export declare enum TimeUnit {
+    NANOSECONDS = "NANOSECONDS",
+    MICROSECONDS = "MICROSECONDS",
+    MILLISECONDS = "MILLISECONDS",
+    SECONDS = "SECONDS",
+    MINUTES = "MINUTES",
+    HOURS = "HOURS",
+    DAYS = "DAYS"
+}

package/dist/dsl/filter/operator.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Discriminator sent as the `op` property of every filter expression. The
+ * values match the server-side `FilterOperator` enum.
+ */
+export declare enum FilterOperator {
+    MATCH_ALL = "MATCH_ALL",
+    MATCH_NONE = "MATCH_NONE",
+    ID = "ID",
+    IDS = "IDS",
+    AGGREGATE_ID = "AGGREGATE_ID",
+    AGGREGATE_IDS = "AGGREGATE_IDS",
+    TENANT_ID = "TENANT_ID",
+    OWNER_ID = "OWNER_ID",
+    SPACE_ID = "SPACE_ID",
+    AND = "AND",
+    OR = "OR",
+    NOR = "NOR",
+    EQ = "EQ",
+    NE = "NE",
+    GT = "GT",
+    GTE = "GTE",
+    LT = "LT",
+    LTE = "LTE",
+    CONTAINS = "CONTAINS",
+    STARTS_WITH = "STARTS_WITH",
+    ENDS_WITH = "ENDS_WITH",
+    IN = "IN",
+    NOT_IN = "NOT_IN",
+    BETWEEN = "BETWEEN",
+    CONTAINS_ALL = "CONTAINS_ALL",
+    IS_EMPTY = "IS_EMPTY",
+    IS_EMPTY_STRING = "IS_EMPTY_STRING",
+    IS_NOT_EMPTY_STRING = "IS_NOT_EMPTY_STRING",
+    IS_NULL = "IS_NULL",
+    IS_NOT_NULL = "IS_NOT_NULL",
+    EXISTS = "EXISTS",
+    NOT_EXISTS = "NOT_EXISTS",
+    DELETION = "DELETION",
+    ELEMENT_MATCH = "ELEMENT_MATCH",
+    SEARCH = "SEARCH",
+    TODAY = "TODAY",
+    BEFORE_TODAY = "BEFORE_TODAY",
+    TOMORROW = "TOMORROW",
+    THIS_WEEK = "THIS_WEEK",
+    NEXT_WEEK = "NEXT_WEEK",
+    LAST_WEEK = "LAST_WEEK",
+    THIS_MONTH = "THIS_MONTH",
+    LAST_MONTH = "LAST_MONTH",
+    YESTERDAY = "YESTERDAY",
+    NEXT_MONTH = "NEXT_MONTH",
+    LAST_YEAR = "LAST_YEAR",
+    THIS_YEAR = "THIS_YEAR",
+    NEXT_YEAR = "NEXT_YEAR",
+    RECENT_DAYS = "RECENT_DAYS",
+    EARLIER_DAYS = "EARLIER_DAYS",
+    /**
+     * The field is strictly before the server's `now + offset`. Needs a Wow
+     * server of 9.2.0 or later.
+     */
+    BEFORE_NOW = "BEFORE_NOW",
+    /**
+     * The field is strictly after the server's `now + offset`. Needs a Wow
+     * server of 9.2.0 or later.
+     */
+    AFTER_NOW = "AFTER_NOW",
+    /**
+     * A computed expression, such as the hours between two time fields,
+     * compared with a number. Evaluated per record, so expensive; a record
+     * whose expression has no value never matches. Needs a Wow server of
+     * 9.2.0 or later.
+     */
+    EXPRESSION = "EXPRESSION"
+}
+/**
+ * Case handling for `CONTAINS`, `STARTS_WITH` and `ENDS_WITH`.
+ */
+export declare enum StringComparison {
+    /**
+     * Characters must match exactly. The default.
+     */
+    CASE_SENSITIVE = "CASE_SENSITIVE",
+    /**
+     * Ignores case. Backends may execute this more expensively.
+     */
+    CASE_INSENSITIVE = "CASE_INSENSITIVE"
+}
+/**
+ * Matching mode of a full-text `SEARCH` filter.
+ */
+export declare enum SearchMode {
+    /**
+     * Analyzed terms match independently; they need not appear together. The
+     * default.
+     */
+    TERMS = "TERMS",
+    /**
+     * Analyzed terms must appear in order and at adjacent positions.
+     */
+    PHRASE = "PHRASE"
+}
+/**
+ * Unit of a numeric epoch time field targeted by a relative time filter.
+ * Ignored when `datePattern` is set.
+ */
+export declare enum TimeUnit {
+    NANOSECONDS = "NANOSECONDS",
+    MICROSECONDS = "MICROSECONDS",
+    MILLISECONDS = "MILLISECONDS",
+    SECONDS = "SECONDS",
+    MINUTES = "MINUTES",
+    HOURS = "HOURS",
+    DAYS = "DAYS"
+}

package/dist/dsl/filter/operator.es.js

@@ -0,0 +1,14 @@
+//#region src/dsl/filter/operator.ts
+var e = /* @__PURE__ */ function(e) {
+	return e.MATCH_ALL = "MATCH_ALL", e.MATCH_NONE = "MATCH_NONE", e.ID = "ID", e.IDS = "IDS", e.AGGREGATE_ID = "AGGREGATE_ID", e.AGGREGATE_IDS = "AGGREGATE_IDS", e.TENANT_ID = "TENANT_ID", e.OWNER_ID = "OWNER_ID", e.SPACE_ID = "SPACE_ID", e.AND = "AND", e.OR = "OR", e.NOR = "NOR", e.EQ = "EQ", e.NE = "NE", e.GT = "GT", e.GTE = "GTE", e.LT = "LT", e.LTE = "LTE", e.CONTAINS = "CONTAINS", e.STARTS_WITH = "STARTS_WITH", e.ENDS_WITH = "ENDS_WITH", e.IN = "IN", e.NOT_IN = "NOT_IN", e.BETWEEN = "BETWEEN", e.CONTAINS_ALL = "CONTAINS_ALL", e.IS_EMPTY = "IS_EMPTY", e.IS_EMPTY_STRING = "IS_EMPTY_STRING", e.IS_NOT_EMPTY_STRING = "IS_NOT_EMPTY_STRING", e.IS_NULL = "IS_NULL", e.IS_NOT_NULL = "IS_NOT_NULL", e.EXISTS = "EXISTS", e.NOT_EXISTS = "NOT_EXISTS", e.DELETION = "DELETION", e.ELEMENT_MATCH = "ELEMENT_MATCH", e.SEARCH = "SEARCH", e.TODAY = "TODAY", e.BEFORE_TODAY = "BEFORE_TODAY", e.TOMORROW = "TOMORROW", e.THIS_WEEK = "THIS_WEEK", e.NEXT_WEEK = "NEXT_WEEK", e.LAST_WEEK = "LAST_WEEK", e.THIS_MONTH = "THIS_MONTH", e.LAST_MONTH = "LAST_MONTH", e.YESTERDAY = "YESTERDAY", e.NEXT_MONTH = "NEXT_MONTH", e.LAST_YEAR = "LAST_YEAR", e.THIS_YEAR = "THIS_YEAR", e.NEXT_YEAR = "NEXT_YEAR", e.RECENT_DAYS = "RECENT_DAYS", e.EARLIER_DAYS = "EARLIER_DAYS", e.BEFORE_NOW = "BEFORE_NOW", e.AFTER_NOW = "AFTER_NOW", e.EXPRESSION = "EXPRESSION", e;
+}({}), t = /* @__PURE__ */ function(e) {
+	return e.CASE_SENSITIVE = "CASE_SENSITIVE", e.CASE_INSENSITIVE = "CASE_INSENSITIVE", e;
+}({}), n = /* @__PURE__ */ function(e) {
+	return e.TERMS = "TERMS", e.PHRASE = "PHRASE", e;
+}({}), r = /* @__PURE__ */ function(e) {
+	return e.NANOSECONDS = "NANOSECONDS", e.MICROSECONDS = "MICROSECONDS", e.MILLISECONDS = "MILLISECONDS", e.SECONDS = "SECONDS", e.MINUTES = "MINUTES", e.HOURS = "HOURS", e.DAYS = "DAYS", e;
+}({});
+//#endregion
+export { e as FilterOperator, n as SearchMode, t as StringComparison, r as TimeUnit };
+
+//# sourceMappingURL=operator.es.js.map

package/dist/dsl/filter/operator.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operator.es.js","names":["FilterOperator","\"MATCH_ALL\"","\"MATCH_NONE\"","\"ID\"","\"IDS\"","\"AGGREGATE_ID\"","\"AGGREGATE_IDS\"","\"TENANT_ID\"","\"OWNER_ID\"","\"SPACE_ID\"","\"AND\"","\"OR\"","\"NOR\"","\"EQ\"","\"NE\"","\"GT\"","\"GTE\"","\"LT\"","\"LTE\"","\"CONTAINS\"","\"STARTS_WITH\"","\"ENDS_WITH\"","\"IN\"","\"NOT_IN\"","\"BETWEEN\"","\"CONTAINS_ALL\"","\"IS_EMPTY\"","\"IS_EMPTY_STRING\"","\"IS_NOT_EMPTY_STRING\"","\"IS_NULL\"","\"IS_NOT_NULL\"","\"EXISTS\"","\"NOT_EXISTS\"","\"DELETION\"","\"ELEMENT_MATCH\"","\"SEARCH\"","\"TODAY\"","\"BEFORE_TODAY\"","\"TOMORROW\"","\"THIS_WEEK\"","\"NEXT_WEEK\"","\"LAST_WEEK\"","\"THIS_MONTH\"","\"LAST_MONTH\"","\"YESTERDAY\"","\"NEXT_MONTH\"","\"LAST_YEAR\"","\"THIS_YEAR\"","\"NEXT_YEAR\"","\"RECENT_DAYS\"","\"EARLIER_DAYS\"","\"BEFORE_NOW\"","\"AFTER_NOW\"","\"EXPRESSION\"","StringComparison","\"CASE_SENSITIVE\"","\"CASE_INSENSITIVE\"","SearchMode","\"TERMS\"","\"PHRASE\"","TimeUnit","\"NANOSECONDS\"","\"MICROSECONDS\"","\"MILLISECONDS\"","\"SECONDS\"","\"MINUTES\"","\"HOURS\"","\"DAYS\""],"sources":["../../../src/dsl/filter/operator.ts"],"sourcesContent":["/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Discriminator sent as the `op` property of every filter expression. The\n * values match the server-side `FilterOperator` enum.\n */\nexport enum FilterOperator {\n  MATCH_ALL = 'MATCH_ALL',\n  MATCH_NONE = 'MATCH_NONE',\n  ID = 'ID',\n  IDS = 'IDS',\n  AGGREGATE_ID = 'AGGREGATE_ID',\n  AGGREGATE_IDS = 'AGGREGATE_IDS',\n  TENANT_ID = 'TENANT_ID',\n  OWNER_ID = 'OWNER_ID',\n  SPACE_ID = 'SPACE_ID',\n  AND = 'AND',\n  OR = 'OR',\n  NOR = 'NOR',\n  EQ = 'EQ',\n  NE = 'NE',\n  GT = 'GT',\n  GTE = 'GTE',\n  LT = 'LT',\n  LTE = 'LTE',\n  CONTAINS = 'CONTAINS',\n  STARTS_WITH = 'STARTS_WITH',\n  ENDS_WITH = 'ENDS_WITH',\n  IN = 'IN',\n  NOT_IN = 'NOT_IN',\n  BETWEEN = 'BETWEEN',\n  CONTAINS_ALL = 'CONTAINS_ALL',\n  IS_EMPTY = 'IS_EMPTY',\n  IS_EMPTY_STRING = 'IS_EMPTY_STRING',\n  IS_NOT_EMPTY_STRING = 'IS_NOT_EMPTY_STRING',\n  IS_NULL = 'IS_NULL',\n  IS_NOT_NULL = 'IS_NOT_NULL',\n  EXISTS = 'EXISTS',\n  NOT_EXISTS = 'NOT_EXISTS',\n  DELETION = 'DELETION',\n  ELEMENT_MATCH = 'ELEMENT_MATCH',\n  SEARCH = 'SEARCH',\n  TODAY = 'TODAY',\n  BEFORE_TODAY = 'BEFORE_TODAY',\n  TOMORROW = 'TOMORROW',\n  THIS_WEEK = 'THIS_WEEK',\n  NEXT_WEEK = 'NEXT_WEEK',\n  LAST_WEEK = 'LAST_WEEK',\n  THIS_MONTH = 'THIS_MONTH',\n  LAST_MONTH = 'LAST_MONTH',\n  YESTERDAY = 'YESTERDAY',\n  NEXT_MONTH = 'NEXT_MONTH',\n  LAST_YEAR = 'LAST_YEAR',\n  THIS_YEAR = 'THIS_YEAR',\n  NEXT_YEAR = 'NEXT_YEAR',\n  RECENT_DAYS = 'RECENT_DAYS',\n  EARLIER_DAYS = 'EARLIER_DAYS',\n  /**\n   * The field is strictly before the server's `now + offset`. Needs a Wow\n   * server of 9.2.0 or later.\n   */\n  BEFORE_NOW = 'BEFORE_NOW',\n  /**\n   * The field is strictly after the server's `now + offset`. Needs a Wow\n   * server of 9.2.0 or later.\n   */\n  AFTER_NOW = 'AFTER_NOW',\n  /**\n   * A computed expression, such as the hours between two time fields,\n   * compared with a number. Evaluated per record, so expensive; a record\n   * whose expression has no value never matches. Needs a Wow server of\n   * 9.2.0 or later.\n   */\n  EXPRESSION = 'EXPRESSION',\n}\n\n/**\n * Case handling for `CONTAINS`, `STARTS_WITH` and `ENDS_WITH`.\n */\nexport enum StringComparison {\n  /**\n   * Characters must match exactly. The default.\n   */\n  CASE_SENSITIVE = 'CASE_SENSITIVE',\n  /**\n   * Ignores case. Backends may execute this more expensively.\n   */\n  CASE_INSENSITIVE = 'CASE_INSENSITIVE',\n}\n\n/**\n * Matching mode of a full-text `SEARCH` filter.\n */\nexport enum SearchMode {\n  /**\n   * Analyzed terms match independently; they need not appear together. The\n   * default.\n   */\n  TERMS = 'TERMS',\n  /**\n   * Analyzed terms must appear in order and at adjacent positions.\n   */\n  PHRASE = 'PHRASE',\n}\n\n/**\n * Unit of a numeric epoch time field targeted by a relative time filter.\n * Ignored when `datePattern` is set.\n */\nexport enum TimeUnit {\n  NANOSECONDS = 'NANOSECONDS',\n  MICROSECONDS = 'MICROSECONDS',\n  MILLISECONDS = 'MILLISECONDS',\n  SECONDS = 'SECONDS',\n  MINUTES = 'MINUTES',\n  HOURS = 'HOURS',\n  DAYS = 'DAYS',\n}\n"],"mappings":";AAiBA,IAAYA,IAAL,yBAAA,GAAA;QACL,EAAAC,YAAA,aACA,EAAAC,aAAA,cACA,EAAAC,KAAA,MACA,EAAAC,MAAA,OACA,EAAAC,eAAA,gBACA,EAAAC,gBAAA,iBACA,EAAAC,YAAA,aACA,EAAAC,WAAA,YACA,EAAAC,WAAA,YACA,EAAAC,MAAA,OACA,EAAAC,KAAA,MACA,EAAAC,MAAA,OACA,EAAAC,KAAA,MACA,EAAAC,KAAA,MACA,EAAAC,KAAA,MACA,EAAAC,MAAA,OACA,EAAAC,KAAA,MACA,EAAAC,MAAA,OACA,EAAAC,WAAA,YACA,EAAAC,cAAA,eACA,EAAAC,YAAA,aACA,EAAAC,KAAA,MACA,EAAAC,SAAA,UACA,EAAAC,UAAA,WACA,EAAAC,eAAA,gBACA,EAAAC,WAAA,YACA,EAAAC,kBAAA,mBACA,EAAAC,sBAAA,uBACA,EAAAC,UAAA,WACA,EAAAC,cAAA,eACA,EAAAC,SAAA,UACA,EAAAC,aAAA,cACA,EAAAC,WAAA,YACA,EAAAC,gBAAA,iBACA,EAAAC,SAAA,UACA,EAAAC,QAAA,SACA,EAAAC,eAAA,gBACA,EAAAC,WAAA,YACA,EAAAC,YAAA,aACA,EAAAC,YAAA,aACA,EAAAC,YAAA,aACA,EAAAC,aAAA,cACA,EAAAC,aAAA,cACA,EAAAC,YAAA,aACA,EAAAC,aAAA,cACA,EAAAC,YAAA,aACA,EAAAC,YAAA,aACA,EAAAC,YAAA,aACA,EAAAC,cAAA,eACA,EAAAC,eAAA,gBAKA,EAAAC,aAAA,cAKA,EAAAC,YAAA,aAOA,EAAAC,aAAA;AACF,EAAA,CAAA,CAAA,GAKYC,IAAL,yBAAA,GAAA;QAIL,EAAAC,iBAAA,kBAIA,EAAAC,mBAAA;AACF,EAAA,CAAA,CAAA,GAKYC,IAAL,yBAAA,GAAA;QAKL,EAAAC,QAAA,SAIA,EAAAC,SAAA;AACF,EAAA,CAAA,CAAA,GAMYC,IAAL,yBAAA,GAAA;QACL,EAAAC,cAAA,eACA,EAAAC,eAAA,gBACA,EAAAC,eAAA,gBACA,EAAAC,UAAA,WACA,EAAAC,UAAA,WACA,EAAAC,QAAA,SACA,EAAAC,OAAA;AACF,EAAA,CAAA,CAAA"}

package/dist/dsl/filter/scope.cjs

@@ -0,0 +1,2 @@
+const e=require("./operator.cjs");function t(n,r,i=!0){switch(n.op){case e.FilterOperator.ID:case e.FilterOperator.IDS:case e.FilterOperator.AGGREGATE_ID:case e.FilterOperator.AGGREGATE_IDS:case e.FilterOperator.TENANT_ID:case e.FilterOperator.OWNER_ID:case e.FilterOperator.SPACE_ID:case e.FilterOperator.DELETION:throw TypeError(`${r} cannot contain root filters.`);case e.FilterOperator.EXPRESSION:if(i)throw TypeError(`${r} cannot contain root filters.`);break;case e.FilterOperator.SEARCH:if(!i||!n.fields?.length)throw TypeError(`${r} cannot contain root filters.`);break;case e.FilterOperator.AND:case e.FilterOperator.OR:case e.FilterOperator.NOR:if(n.operands.length===0)throw TypeError(`${n.op} operands cannot be empty.`);if(n.operands.some(e=>e==null))throw TypeError(`${n.op} operands cannot contain null.`);n.operands.forEach(e=>t(e,r,i));break;case e.FilterOperator.ELEMENT_MATCH:t(n.predicate,r,i)}}exports.requireElementScopedFilter=t;
+//# sourceMappingURL=scope.cjs.map

package/dist/dsl/filter/scope.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"scope.cjs","names":["FilterOperator","require_operator","requireElementScopedFilter","expression","subject","fieldSearch","operand"],"sources":["../../../src/dsl/filter/scope.ts"],"sourcesContent":["/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n// Internal: not re-exported by filter/index.ts. `filter.elementMatch` and an\n// aggregation element's own filter both scope a filter to an element; this is\n// the one rule they share.\nimport { FilterOperator } from './operator.js';\nimport type { FilterExpression } from './types.js';\n\n/**\n * Refuses the filters that only a whole record can answer.\n *\n * The metadata filters, `DELETION` and a model-wide `SEARCH` ask about the\n * record — its id, its owner, whether it is deleted, its text — and an\n * element is not a record. Wow calls them root filters and refuses them in\n * both places a filter is scoped to an element: an `ELEMENT_MATCH` predicate\n * and an aggregation element's own filter. A `SEARCH` that names its fields\n * asks about the element's text, which an `ELEMENT_MATCH` predicate takes\n * (`fieldSearch`) and an aggregation element's filter does not; an\n * `EXPRESSION` filter goes the other way round. `subject`\n * names which one, so the complaint points at the call that made it.\n */\nexport function requireElementScopedFilter(\n  expression: FilterExpression,\n  subject: string,\n  fieldSearch = true,\n): void {\n  switch (expression.op) {\n    case FilterOperator.ID:\n    case FilterOperator.IDS:\n    case FilterOperator.AGGREGATE_ID:\n    case FilterOperator.AGGREGATE_IDS:\n    case FilterOperator.TENANT_ID:\n    case FilterOperator.OWNER_ID:\n    case FilterOperator.SPACE_ID:\n    case FilterOperator.DELETION:\n      throw new TypeError(`${subject} cannot contain root filters.`);\n    // A computed comparison cannot run inside ELEMENT_MATCH on every storage;\n    // an aggregation element's filter takes it.\n    case FilterOperator.EXPRESSION:\n      if (fieldSearch)\n        throw new TypeError(`${subject} cannot contain root filters.`);\n      break;\n    case FilterOperator.SEARCH:\n      if (!fieldSearch || !expression.fields?.length)\n        throw new TypeError(`${subject} cannot contain root filters.`);\n      break;\n    case FilterOperator.AND:\n    case FilterOperator.OR:\n    case FilterOperator.NOR:\n      if (expression.operands.length === 0) {\n        throw new TypeError(`${expression.op} operands cannot be empty.`);\n      }\n      if (expression.operands.some(operand => operand == null)) {\n        throw new TypeError(`${expression.op} operands cannot contain null.`);\n      }\n      expression.operands.forEach(operand =>\n        requireElementScopedFilter(operand, subject, fieldSearch),\n      );\n      break;\n    case FilterOperator.ELEMENT_MATCH:\n      requireElementScopedFilter(expression.predicate, subject, fieldSearch);\n      break;\n  }\n}\n"],"mappings":"kCAgCA,SAAgBE,EACd,EACA,EACA,EAAc,GACR,CACN,OAAQC,EAAW,GAAnB,CACE,KAAKH,EAAAA,eAAe,GACpB,KAAKA,EAAAA,eAAe,IACpB,KAAKA,EAAAA,eAAe,aACpB,KAAKA,EAAAA,eAAe,cACpB,KAAKA,EAAAA,eAAe,UACpB,KAAKA,EAAAA,eAAe,SACpB,KAAKA,EAAAA,eAAe,SACpB,KAAKA,EAAAA,eAAe,SAClB,MAAU,UAAU,GAAGI,EAAQ,8BAA8B,EAG/D,KAAKJ,EAAAA,eAAe,WAClB,GAAIK,EACF,MAAU,UAAU,GAAGD,EAAQ,8BAA8B,EAC/D,MACF,KAAKJ,EAAAA,eAAe,OAClB,GAAI,CAACK,GAAe,CAACF,EAAW,QAAQ,OACtC,MAAU,UAAU,GAAGC,EAAQ,8BAA8B,EAC/D,MACF,KAAKJ,EAAAA,eAAe,IACpB,KAAKA,EAAAA,eAAe,GACpB,KAAKA,EAAAA,eAAe,IAClB,GAAIG,EAAW,SAAS,SAAW,EACjC,MAAU,UAAU,GAAGA,EAAW,GAAG,2BAA2B,EAElE,GAAIA,EAAW,SAAS,KAAK,GAAWG,GAAW,IAAI,EACrD,MAAU,UAAU,GAAGH,EAAW,GAAG,+BAA+B,EAEtEA,EAAW,SAAS,QAAQ,GAC1BD,EAA2BI,EAASF,EAASC,CAAW,CAC1D,EACA,MACF,KAAKL,EAAAA,eAAe,cAClBE,EAA2BC,EAAW,UAAWC,EAASC,CAAW,CAEzE,CACF"}

package/dist/dsl/filter/scope.d.cts

@@ -0,0 +1,15 @@
+import { FilterExpression } from './types.cjs';
+/**
+ * Refuses the filters that only a whole record can answer.
+ *
+ * The metadata filters, `DELETION` and a model-wide `SEARCH` ask about the
+ * record — its id, its owner, whether it is deleted, its text — and an
+ * element is not a record. Wow calls them root filters and refuses them in
+ * both places a filter is scoped to an element: an `ELEMENT_MATCH` predicate
+ * and an aggregation element's own filter. A `SEARCH` that names its fields
+ * asks about the element's text, which an `ELEMENT_MATCH` predicate takes
+ * (`fieldSearch`) and an aggregation element's filter does not; an
+ * `EXPRESSION` filter goes the other way round. `subject`
+ * names which one, so the complaint points at the call that made it.
+ */
+export declare function requireElementScopedFilter(expression: FilterExpression, subject: string, fieldSearch?: boolean): void;

package/dist/dsl/filter/scope.d.ts

@@ -0,0 +1,15 @@
+import { FilterExpression } from './types.js';
+/**
+ * Refuses the filters that only a whole record can answer.
+ *
+ * The metadata filters, `DELETION` and a model-wide `SEARCH` ask about the
+ * record — its id, its owner, whether it is deleted, its text — and an
+ * element is not a record. Wow calls them root filters and refuses them in
+ * both places a filter is scoped to an element: an `ELEMENT_MATCH` predicate
+ * and an aggregation element's own filter. A `SEARCH` that names its fields
+ * asks about the element's text, which an `ELEMENT_MATCH` predicate takes
+ * (`fieldSearch`) and an aggregation element's filter does not; an
+ * `EXPRESSION` filter goes the other way round. `subject`
+ * names which one, so the complaint points at the call that made it.
+ */
+export declare function requireElementScopedFilter(expression: FilterExpression, subject: string, fieldSearch?: boolean): void;

package/dist/dsl/filter/scope.es.js

@@ -0,0 +1,32 @@
+import { FilterOperator as e } from "./operator.es.js";
+//#region src/dsl/filter/scope.ts
+function t(n, r, i = !0) {
+	switch (n.op) {
+		case e.ID:
+		case e.IDS:
+		case e.AGGREGATE_ID:
+		case e.AGGREGATE_IDS:
+		case e.TENANT_ID:
+		case e.OWNER_ID:
+		case e.SPACE_ID:
+		case e.DELETION: throw TypeError(`${r} cannot contain root filters.`);
+		case e.EXPRESSION:
+			if (i) throw TypeError(`${r} cannot contain root filters.`);
+			break;
+		case e.SEARCH:
+			if (!i || !n.fields?.length) throw TypeError(`${r} cannot contain root filters.`);
+			break;
+		case e.AND:
+		case e.OR:
+		case e.NOR:
+			if (n.operands.length === 0) throw TypeError(`${n.op} operands cannot be empty.`);
+			if (n.operands.some((e) => e == null)) throw TypeError(`${n.op} operands cannot contain null.`);
+			n.operands.forEach((e) => t(e, r, i));
+			break;
+		case e.ELEMENT_MATCH: t(n.predicate, r, i);
+	}
+}
+//#endregion
+export { t as requireElementScopedFilter };
+
+//# sourceMappingURL=scope.es.js.map

package/dist/dsl/filter/scope.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scope.es.js","names":["requireElementScopedFilter","expression","FilterOperator","subject","fieldSearch","operand"],"sources":["../../../src/dsl/filter/scope.ts"],"sourcesContent":["/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n// Internal: not re-exported by filter/index.ts. `filter.elementMatch` and an\n// aggregation element's own filter both scope a filter to an element; this is\n// the one rule they share.\nimport { FilterOperator } from './operator.js';\nimport type { FilterExpression } from './types.js';\n\n/**\n * Refuses the filters that only a whole record can answer.\n *\n * The metadata filters, `DELETION` and a model-wide `SEARCH` ask about the\n * record — its id, its owner, whether it is deleted, its text — and an\n * element is not a record. Wow calls them root filters and refuses them in\n * both places a filter is scoped to an element: an `ELEMENT_MATCH` predicate\n * and an aggregation element's own filter. A `SEARCH` that names its fields\n * asks about the element's text, which an `ELEMENT_MATCH` predicate takes\n * (`fieldSearch`) and an aggregation element's filter does not; an\n * `EXPRESSION` filter goes the other way round. `subject`\n * names which one, so the complaint points at the call that made it.\n */\nexport function requireElementScopedFilter(\n  expression: FilterExpression,\n  subject: string,\n  fieldSearch = true,\n): void {\n  switch (expression.op) {\n    case FilterOperator.ID:\n    case FilterOperator.IDS:\n    case FilterOperator.AGGREGATE_ID:\n    case FilterOperator.AGGREGATE_IDS:\n    case FilterOperator.TENANT_ID:\n    case FilterOperator.OWNER_ID:\n    case FilterOperator.SPACE_ID:\n    case FilterOperator.DELETION:\n      throw new TypeError(`${subject} cannot contain root filters.`);\n    // A computed comparison cannot run inside ELEMENT_MATCH on every storage;\n    // an aggregation element's filter takes it.\n    case FilterOperator.EXPRESSION:\n      if (fieldSearch)\n        throw new TypeError(`${subject} cannot contain root filters.`);\n      break;\n    case FilterOperator.SEARCH:\n      if (!fieldSearch || !expression.fields?.length)\n        throw new TypeError(`${subject} cannot contain root filters.`);\n      break;\n    case FilterOperator.AND:\n    case FilterOperator.OR:\n    case FilterOperator.NOR:\n      if (expression.operands.length === 0) {\n        throw new TypeError(`${expression.op} operands cannot be empty.`);\n      }\n      if (expression.operands.some(operand => operand == null)) {\n        throw new TypeError(`${expression.op} operands cannot contain null.`);\n      }\n      expression.operands.forEach(operand =>\n        requireElementScopedFilter(operand, subject, fieldSearch),\n      );\n      break;\n    case FilterOperator.ELEMENT_MATCH:\n      requireElementScopedFilter(expression.predicate, subject, fieldSearch);\n      break;\n  }\n}\n"],"mappings":";;AAgCA,SAAgBA,EACd,GACA,GACA,IAAc,IACR;CACN,QAAQC,EAAW,IAAnB;EACE,KAAKC,EAAe;EACpB,KAAKA,EAAe;EACpB,KAAKA,EAAe;EACpB,KAAKA,EAAe;EACpB,KAAKA,EAAe;EACpB,KAAKA,EAAe;EACpB,KAAKA,EAAe;EACpB,KAAKA,EAAe,UAClB,MAAU,UAAU,GAAGC,EAAQ,8BAA8B;EAG/D,KAAKD,EAAe;GAClB,IAAIE,GACF,MAAU,UAAU,GAAGD,EAAQ,8BAA8B;GAC/D;EACF,KAAKD,EAAe;GAClB,IAAI,CAACE,KAAe,CAACH,EAAW,QAAQ,QACtC,MAAU,UAAU,GAAGE,EAAQ,8BAA8B;GAC/D;EACF,KAAKD,EAAe;EACpB,KAAKA,EAAe;EACpB,KAAKA,EAAe;GAClB,IAAID,EAAW,SAAS,WAAW,GACjC,MAAU,UAAU,GAAGA,EAAW,GAAG,2BAA2B;GAElE,IAAIA,EAAW,SAAS,MAAK,MAAWI,KAAW,IAAI,GACrD,MAAU,UAAU,GAAGJ,EAAW,GAAG,+BAA+B;GAEtE,EAAW,SAAS,SAAQ,MAC1BD,EAA2BK,GAASF,GAASC,CAAW,CAC1D;GACA;EACF,KAAKF,EAAe,eAClB,EAA2BD,EAAW,WAAWE,GAASC,CAAW;CAEzE;AACF"}

package/dist/dsl/filter/types.d.cts

@@ -0,0 +1,274 @@
+import { AggregationExpression, ComparisonOperator } from '../aggregation/types.cjs';
+import { DeletionState } from '../deletionState.cjs';
+import { FilterOperator, SearchMode, StringComparison, TimeUnit } from './operator.cjs';
+/**
+ * Dot-separated logical field path. The first segment is a name; later
+ * segments are names or decimal array indexes. A name may start with `@`,
+ * begins with an ASCII letter or `_`, and continues with ASCII letters,
+ * digits, `_` or `-`. Builders throw `TypeError` for any other string.
+ */
+export type QueryField<FIELDS extends string = string> = FIELDS;
+/**
+ * JSON scalar accepted as a filter value. Numbers must be finite.
+ */
+export type FilterLiteral = null | string | number | boolean;
+/**
+ * Value accepted by `EQ` and `NE`, including `null`.
+ */
+export type EqualityFilterValue = FilterLiteral;
+/**
+ * Non-null JSON scalar accepted by comparison, range and collection filters.
+ */
+export type ComparableFilterLiteral = Exclude<FilterLiteral, null>;
+/**
+ * Constant filter: `MATCH_ALL` matches everything in the query scope,
+ * `MATCH_NONE` matches nothing.
+ */
+export type MatchFilter = {
+    op: FilterOperator.MATCH_ALL | FilterOperator.MATCH_NONE;
+};
+/**
+ * Root-only filter on one system identifier: record ID, aggregate ID,
+ * tenant, owner or space.
+ */
+export type MetadataValueFilter = {
+    op: FilterOperator.ID | FilterOperator.AGGREGATE_ID | FilterOperator.TENANT_ID | FilterOperator.OWNER_ID | FilterOperator.SPACE_ID;
+    value: string;
+};
+/**
+ * Root-only filter on a non-empty set of record IDs or aggregate IDs.
+ */
+export type MetadataValuesFilter = {
+    op: FilterOperator.IDS | FilterOperator.AGGREGATE_IDS;
+    values: string[];
+};
+/**
+ * Any root-only system identifier filter.
+ */
+export type MetadataFilter = MetadataValueFilter | MetadataValuesFilter;
+/**
+ * `AND`, `OR` or `NOR` over a non-empty list of filter expressions.
+ */
+export type LogicalFilter<FIELDS extends string = string> = {
+    op: FilterOperator.AND | FilterOperator.OR | FilterOperator.NOR;
+    operands: FilterExpression<FIELDS>[];
+};
+/**
+ * `AND`, `OR` or `NOR` whose operands are all valid inside an
+ * `ELEMENT_MATCH` predicate.
+ */
+export type ElementLogicalFilter<FIELDS extends string = string> = {
+    op: FilterOperator.AND | FilterOperator.OR | FilterOperator.NOR;
+    operands: ElementFilterExpression<FIELDS>[];
+};
+/**
+ * `EQ` or `NE` on a field. The server rewrites a `null` value to `IS_NULL`
+ * or `IS_NOT_NULL`.
+ */
+export type EqualityFilter<FIELDS extends string = string> = {
+    op: FilterOperator.EQ | FilterOperator.NE;
+    field: QueryField<FIELDS>;
+    value: EqualityFilterValue;
+};
+/**
+ * `GT`, `GTE`, `LT` or `LTE` on a field against a non-null scalar.
+ */
+export type ComparisonFilter<FIELDS extends string = string> = {
+    op: FilterOperator.GT | FilterOperator.GTE | FilterOperator.LT | FilterOperator.LTE;
+    field: QueryField<FIELDS>;
+    value: ComparableFilterLiteral;
+};
+/**
+ * Literal substring, prefix or suffix match on a string field. No full-text
+ * analyzer is applied. `stringComparison` defaults to `CASE_SENSITIVE`.
+ */
+export type StringFilter<FIELDS extends string = string> = {
+    op: FilterOperator.CONTAINS | FilterOperator.STARTS_WITH | FilterOperator.ENDS_WITH;
+    field: QueryField<FIELDS>;
+    value: string;
+    stringComparison?: StringComparison;
+};
+/**
+ * `IN`, `NOT_IN` or `CONTAINS_ALL` on a field against a non-empty list of
+ * non-null scalars.
+ */
+export type CollectionFilter<FIELDS extends string = string> = {
+    op: FilterOperator.IN | FilterOperator.NOT_IN | FilterOperator.CONTAINS_ALL;
+    field: QueryField<FIELDS>;
+    values: ComparableFilterLiteral[];
+};
+/**
+ * Inclusive range on a field: `lowerBound <= field <= upperBound`.
+ */
+export type BetweenFilter<FIELDS extends string = string> = {
+    op: FilterOperator.BETWEEN;
+    field: QueryField<FIELDS>;
+    lowerBound: ComparableFilterLiteral;
+    upperBound: ComparableFilterLiteral;
+};
+/**
+ * Operand-free check of a field's null, existence, empty-collection or
+ * empty-string state.
+ */
+export type FieldPresenceFilter<FIELDS extends string = string> = {
+    op: FilterOperator.IS_EMPTY | FilterOperator.IS_EMPTY_STRING | FilterOperator.IS_NOT_EMPTY_STRING | FilterOperator.IS_NULL | FilterOperator.IS_NOT_NULL | FilterOperator.EXISTS | FilterOperator.NOT_EXISTS;
+    field: QueryField<FIELDS>;
+};
+/**
+ * Root-only filter on the deletion state of snapshots.
+ */
+export type DeletionFilter = {
+    op: FilterOperator.DELETION;
+    state: DeletionState;
+};
+/**
+ * Matches when a single element of the array `field` satisfies `predicate`.
+ * Predicate fields are relative to the element.
+ */
+export type ElementMatchFilter<FIELDS extends string = string, ELEMENT_FIELDS extends string = string> = {
+    op: FilterOperator.ELEMENT_MATCH;
+    field: QueryField<FIELDS>;
+    predicate: ElementFilterExpression<ELEMENT_FIELDS>;
+};
+/**
+ * Full-text search. Matching depends on the backend's index and analyzer.
+ * Empty `fields` means the backend's default search fields, a model-wide
+ * search, which only a record can answer; inside an `ELEMENT_MATCH` a
+ * search must name its fields: see {@link ElementSearchFilter}.
+ */
+export type SearchFilter<FIELDS extends string = string> = {
+    op: FilterOperator.SEARCH;
+    query: string;
+    fields?: QueryField<FIELDS>[];
+    /**
+     * Matching mode. Defaults to `SearchMode.TERMS`.
+     */
+    mode?: SearchMode;
+};
+/**
+ * A `SEARCH` that names at least one field: the only search an
+ * `ELEMENT_MATCH` predicate takes, with fields relative to the element.
+ * `filter.search(query, { fields: ['name'] })` builds one. Wow 9.2 and
+ * later, on a storage that lists `elements[].search` in the descriptor.
+ */
+export type ElementSearchFilter<FIELDS extends string = string> = SearchFilter<FIELDS> & {
+    fields: [QueryField<FIELDS>, ...QueryField<FIELDS>[]];
+};
+/**
+ * Options for {@link filter.search}.
+ */
+export interface SearchFilterOptions<FIELDS extends string = string> {
+    /**
+     * Fields to search. Defaults to `[]`, the backend's default search fields.
+     */
+    fields?: readonly QueryField<FIELDS>[];
+    /**
+     * Matching mode. Defaults to `SearchMode.TERMS`.
+     */
+    mode?: SearchMode;
+}
+/**
+ * Options shared by relative time filters. Unset options are omitted from
+ * the payload, except `timeUnit`, which the builders always send.
+ */
+export interface RelativeTimeFilterOptions {
+    /**
+     * Time zone that defines calendar days, e.g. `Asia/Shanghai` or `+08:00`.
+     * Defaults to the server process time zone. Must not be blank. A value
+     * that starts with an optional `UTC`, `GMT` or `UT` prefix followed by `+`
+     * or `-` must be a valid offset within +/-18:00; region IDs are checked by
+     * the server only.
+     */
+    zoneId?: string;
+    /**
+     * `java.time.format.DateTimeFormatter` pattern for fields stored as
+     * formatted strings, e.g. `yyyy-MM-dd`. Must equal the pattern declared by
+     * the query schema. Must not be blank.
+     */
+    datePattern?: string;
+    /**
+     * Unit of a numeric epoch field. Defaults to `TimeUnit.MILLISECONDS`.
+     * Ignored when `datePattern` is set.
+     */
+    timeUnit?: TimeUnit;
+}
+/**
+ * Matches times in a calendar window relative to now: `[start, end)` in the
+ * configured time zone. Weeks start on Monday.
+ */
+export type CalendarFilter<FIELDS extends string = string> = RelativeTimeFilterOptions & {
+    op: FilterOperator.TODAY | FilterOperator.TOMORROW | FilterOperator.THIS_WEEK | FilterOperator.NEXT_WEEK | FilterOperator.LAST_WEEK | FilterOperator.THIS_MONTH | FilterOperator.LAST_MONTH | FilterOperator.YESTERDAY | FilterOperator.NEXT_MONTH | FilterOperator.LAST_YEAR | FilterOperator.THIS_YEAR | FilterOperator.NEXT_YEAR;
+    field: QueryField<FIELDS>;
+};
+/**
+ * Matches times earlier than today at the local time `time`.
+ */
+export type BeforeTodayFilter<FIELDS extends string = string> = RelativeTimeFilterOptions & {
+    op: FilterOperator.BEFORE_TODAY;
+    field: QueryField<FIELDS>;
+    time: string;
+};
+/**
+ * `RECENT_DAYS` matches today and the `days - 1` previous calendar days;
+ * `EARLIER_DAYS` matches times before that window.
+ */
+export type DaysFilter<FIELDS extends string = string> = RelativeTimeFilterOptions & {
+    op: FilterOperator.RECENT_DAYS | FilterOperator.EARLIER_DAYS;
+    field: QueryField<FIELDS>;
+    days: number;
+};
+/**
+ * `BEFORE_NOW` matches times strictly before the server's `now + offset`;
+ * `AFTER_NOW` matches times strictly after it. The server reads its clock
+ * once per query, so every condition of one query compares against the same
+ * moment and a saved query never depends on the client's clock. `offset` is
+ * an ISO-8601 duration (`PT0S`, `-PT30M`, `P1DT2H`); a negative offset looks
+ * back.
+ *
+ * Needs a Wow server of 9.2.0 or later; an earlier one refuses the operator.
+ */
+export type NowFilter<FIELDS extends string = string> = RelativeTimeFilterOptions & {
+    op: FilterOperator.BEFORE_NOW | FilterOperator.AFTER_NOW;
+    field: QueryField<FIELDS>;
+    offset: string;
+};
+/**
+ * Filter expression allowed inside an `ELEMENT_MATCH` predicate. Excludes
+ * root-only filters: system identifiers, `DELETION` and a model-wide
+ * `SEARCH`; a `SEARCH` that names its fields is an element predicate. An
+ * aggregation element's filter takes no `SEARCH` at all, which
+ * {@link aggregation.element} checks when it runs.
+ */
+export type ElementFilterExpression<FIELDS extends string = string> = MatchFilter | ElementLogicalFilter<FIELDS> | EqualityFilter<FIELDS> | ComparisonFilter<FIELDS> | StringFilter<FIELDS> | CollectionFilter<FIELDS> | BetweenFilter<FIELDS> | FieldPresenceFilter<FIELDS> | ElementMatchFilter<FIELDS> | CalendarFilter<FIELDS> | BeforeTodayFilter<FIELDS> | DaysFilter<FIELDS> | NowFilter<FIELDS> | ElementSearchFilter<FIELDS>;
+/**
+ * A computed expression compared with a number; {@link filter.expression}.
+ * The expression is an {@link AggregationExpression}, such as a `DATE_DIFF`
+ * between two time fields, evaluated per record. A record whose expression
+ * has no value (an operand is absent or holds several values, or a division
+ * by zero) does not match, whatever the comparison, `NE` included.
+ *
+ * Allowed at the root, in a metric's filter and in an aggregation element's
+ * filter, but not inside `ELEMENT_MATCH`. It is an expensive operator: the
+ * descriptor lists `EXPRESSION` in `record.rootOperators` only where the
+ * server allows expensive operators. Wow 9.2 and later.
+ */
+export type ExpressionFilter<FIELDS extends string = string> = {
+    op: FilterOperator.EXPRESSION;
+    /** The per-record value compared; it reads at least one field. */
+    expression: AggregationExpression<FIELDS>;
+    /** How the value compares with `value`. */
+    comparison: ComparisonOperator;
+    /** A finite number. */
+    value: number;
+};
+/**
+ * Filter expression sent to the query API. Build values with
+ * {@link filter}.
+ */
+export type FilterExpression<FIELDS extends string = string> = MatchFilter | MetadataFilter | LogicalFilter<FIELDS> | EqualityFilter<FIELDS> | ComparisonFilter<FIELDS> | StringFilter<FIELDS> | CollectionFilter<FIELDS> | BetweenFilter<FIELDS> | FieldPresenceFilter<FIELDS> | DeletionFilter | ElementMatchFilter<FIELDS> | SearchFilter<FIELDS> | CalendarFilter<FIELDS> | BeforeTodayFilter<FIELDS> | DaysFilter<FIELDS> | NowFilter<FIELDS> | ExpressionFilter<FIELDS>;
+/**
+ * Query that carries a filter expression.
+ */
+export interface FilterCapable<FIELDS extends string = string> {
+    filter: FilterExpression<FIELDS>;
+}