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

package/dist/dsl/aggregation/having.d.ts

@@ -0,0 +1,94 @@
+import { HavingExpression } from './types.js';
+/**
+ * The builders of a `having` expression, `aggregation.having.*`: conditions on
+ * the metric columns of the grouped rows, and their `and`/`or`. Mirrors
+ * Kotlin's `HavingDsl` (`wow-query`, `AggregationQueryDsl.kt`).
+ *
+ * Each builder checks its own numbers and throws a `TypeError` with the
+ * message Wow answers; `aggregation.query()` checks what spans the query:
+ * that `metric` names a declared, non-ANY metric, and that the query groups.
+ */
+export interface HavingDsl {
+    /**
+     * `metric = value`. `{ type: 'CONDITION', metric, operator: 'EQ', value }`.
+     *
+     * @param metric - The alias of a metric of the same query.
+     * @throws TypeError when `value` is not finite.
+     * @example
+     * ```typescript
+     * aggregation.having.eq('orders', 1);
+     * ```
+     */
+    eq(metric: string, value: number): HavingExpression;
+    /** `metric ≠ value`. `{ type: 'CONDITION', operator: 'NE', … }`. */
+    ne(metric: string, value: number): HavingExpression;
+    /**
+     * `metric > value`. `{ type: 'CONDITION', operator: 'GT', … }`.
+     *
+     * @example
+     * ```typescript
+     * aggregation.having.gt('revenue', 100);
+     * ```
+     */
+    gt(metric: string, value: number): HavingExpression;
+    /** `metric ≥ value`. `{ type: 'CONDITION', operator: 'GTE', … }`. */
+    gte(metric: string, value: number): HavingExpression;
+    /** `metric < value`. `{ type: 'CONDITION', operator: 'LT', … }`. */
+    lt(metric: string, value: number): HavingExpression;
+    /** `metric ≤ value`. `{ type: 'CONDITION', operator: 'LTE', … }`. */
+    lte(metric: string, value: number): HavingExpression;
+    /**
+     * `lower ≤ metric ≤ upper`. `{ type: 'BETWEEN', metric, lower, upper }`.
+     *
+     * @throws TypeError when a bound is not finite, or `lower` exceeds `upper`.
+     * @example
+     * ```typescript
+     * aggregation.having.between('revenue', 10, 1000);
+     * ```
+     */
+    between(metric: string, lower: number, upper: number): HavingExpression;
+    /**
+     * `metric` is one of `values`. `{ type: 'IN', metric, values }` with a
+     * copy of `values`.
+     *
+     * @throws TypeError when `values` is empty or holds a non-finite number.
+     * @example
+     * ```typescript
+     * aggregation.having.isIn('orders', [2, 3]);
+     * ```
+     */
+    isIn(metric: string, values: readonly number[]): HavingExpression;
+    /**
+     * `metric` has no value in the row. `{ type: 'IS_NULL', metric }`.
+     *
+     * @example
+     * ```typescript
+     * aggregation.having.isNull('averageOrder');
+     * ```
+     */
+    isNull(metric: string): HavingExpression;
+    /** `metric` has a value. `{ type: 'IS_NULL', metric, negated: true }`. */
+    isNotNull(metric: string): HavingExpression;
+    /**
+     * All of `operands` hold. `{ type: 'AND', operands }` with a copy of
+     * `operands`.
+     *
+     * @throws TypeError when `operands` is empty.
+     * @example
+     * ```typescript
+     * aggregation.having.and([
+     *   aggregation.having.gt('orders', 1),
+     *   aggregation.having.isNotNull('revenue'),
+     * ]);
+     * ```
+     */
+    and(operands: readonly HavingExpression[]): HavingExpression;
+    /**
+     * At least one of `operands` holds. `{ type: 'OR', operands }` with a copy
+     * of `operands`.
+     *
+     * @throws TypeError when `operands` is empty.
+     */
+    or(operands: readonly HavingExpression[]): HavingExpression;
+}
+export declare const havingDsl: HavingDsl;

package/dist/dsl/aggregation/having.es.js

@@ -0,0 +1,62 @@
+import { ComparisonOperator as e, HavingExpressionType as t } from "./types.es.js";
+//#region src/dsl/aggregation/having.ts
+function n(e, n, r) {
+	if (!Number.isFinite(r)) throw TypeError(`having condition [${n}] value must be finite.`);
+	return {
+		type: t.CONDITION,
+		metric: n,
+		operator: e,
+		value: r
+	};
+}
+function r(e, t) {
+	let [n, ...r] = t;
+	if (n === void 0) throw TypeError(`having ${e} operands must not be empty.`);
+	return {
+		type: e,
+		operands: [n, ...r]
+	};
+}
+var i = {
+	eq: (t, r) => n(e.EQ, t, r),
+	ne: (t, r) => n(e.NE, t, r),
+	gt: (t, r) => n(e.GT, t, r),
+	gte: (t, r) => n(e.GTE, t, r),
+	lt: (t, r) => n(e.LT, t, r),
+	lte: (t, r) => n(e.LTE, t, r),
+	between(e, n, r) {
+		if (!Number.isFinite(n) || !Number.isFinite(r)) throw TypeError(`having between [${e}] bounds must be finite.`);
+		if (n > r) throw TypeError(`having between [${e}] lower bound must not exceed upper bound.`);
+		return {
+			type: t.BETWEEN,
+			metric: e,
+			lower: n,
+			upper: r
+		};
+	},
+	isIn(e, n) {
+		let [r, ...i] = n;
+		if (r === void 0) throw TypeError(`having in [${e}] values must not be empty.`);
+		if (!n.every(Number.isFinite)) throw TypeError(`having in [${e}] values must be finite.`);
+		return {
+			type: t.IN,
+			metric: e,
+			values: [r, ...i]
+		};
+	},
+	isNull: (e) => ({
+		type: t.IS_NULL,
+		metric: e
+	}),
+	isNotNull: (e) => ({
+		type: t.IS_NULL,
+		metric: e,
+		negated: !0
+	}),
+	and: (e) => r(t.AND, e),
+	or: (e) => r(t.OR, e)
+};
+//#endregion
+export { i as havingDsl };
+
+//# sourceMappingURL=having.es.js.map

package/dist/dsl/aggregation/having.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"having.es.js","names":["condition","value","metric","HavingExpressionType","logical","first","rest","operands","type","havingDsl","ComparisonOperator","lower","upper","values"],"sources":["../../../src/dsl/aggregation/having.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\nimport {\n  ComparisonOperator,\n  HavingExpressionType,\n  type HavingExpression,\n} from './types.js';\n\n/**\n * The builders of a `having` expression, `aggregation.having.*`: conditions on\n * the metric columns of the grouped rows, and their `and`/`or`. Mirrors\n * Kotlin's `HavingDsl` (`wow-query`, `AggregationQueryDsl.kt`).\n *\n * Each builder checks its own numbers and throws a `TypeError` with the\n * message Wow answers; `aggregation.query()` checks what spans the query:\n * that `metric` names a declared, non-ANY metric, and that the query groups.\n */\nexport interface HavingDsl {\n  /**\n   * `metric = value`. `{ type: 'CONDITION', metric, operator: 'EQ', value }`.\n   *\n   * @param metric - The alias of a metric of the same query.\n   * @throws TypeError when `value` is not finite.\n   * @example\n   * ```typescript\n   * aggregation.having.eq('orders', 1);\n   * ```\n   */\n  eq(metric: string, value: number): HavingExpression;\n  /** `metric ≠ value`. `{ type: 'CONDITION', operator: 'NE', … }`. */\n  ne(metric: string, value: number): HavingExpression;\n  /**\n   * `metric > value`. `{ type: 'CONDITION', operator: 'GT', … }`.\n   *\n   * @example\n   * ```typescript\n   * aggregation.having.gt('revenue', 100);\n   * ```\n   */\n  gt(metric: string, value: number): HavingExpression;\n  /** `metric ≥ value`. `{ type: 'CONDITION', operator: 'GTE', … }`. */\n  gte(metric: string, value: number): HavingExpression;\n  /** `metric < value`. `{ type: 'CONDITION', operator: 'LT', … }`. */\n  lt(metric: string, value: number): HavingExpression;\n  /** `metric ≤ value`. `{ type: 'CONDITION', operator: 'LTE', … }`. */\n  lte(metric: string, value: number): HavingExpression;\n  /**\n   * `lower ≤ metric ≤ upper`. `{ type: 'BETWEEN', metric, lower, upper }`.\n   *\n   * @throws TypeError when a bound is not finite, or `lower` exceeds `upper`.\n   * @example\n   * ```typescript\n   * aggregation.having.between('revenue', 10, 1000);\n   * ```\n   */\n  between(metric: string, lower: number, upper: number): HavingExpression;\n  /**\n   * `metric` is one of `values`. `{ type: 'IN', metric, values }` with a\n   * copy of `values`.\n   *\n   * @throws TypeError when `values` is empty or holds a non-finite number.\n   * @example\n   * ```typescript\n   * aggregation.having.isIn('orders', [2, 3]);\n   * ```\n   */\n  isIn(metric: string, values: readonly number[]): HavingExpression;\n  /**\n   * `metric` has no value in the row. `{ type: 'IS_NULL', metric }`.\n   *\n   * @example\n   * ```typescript\n   * aggregation.having.isNull('averageOrder');\n   * ```\n   */\n  isNull(metric: string): HavingExpression;\n  /** `metric` has a value. `{ type: 'IS_NULL', metric, negated: true }`. */\n  isNotNull(metric: string): HavingExpression;\n  /**\n   * All of `operands` hold. `{ type: 'AND', operands }` with a copy of\n   * `operands`.\n   *\n   * @throws TypeError when `operands` is empty.\n   * @example\n   * ```typescript\n   * aggregation.having.and([\n   *   aggregation.having.gt('orders', 1),\n   *   aggregation.having.isNotNull('revenue'),\n   * ]);\n   * ```\n   */\n  and(operands: readonly HavingExpression[]): HavingExpression;\n  /**\n   * At least one of `operands` holds. `{ type: 'OR', operands }` with a copy\n   * of `operands`.\n   *\n   * @throws TypeError when `operands` is empty.\n   */\n  or(operands: readonly HavingExpression[]): HavingExpression;\n}\n\nfunction condition(\n  operator: ComparisonOperator,\n  metric: string,\n  value: number,\n): HavingExpression {\n  if (!Number.isFinite(value)) {\n    throw new TypeError(`having condition [${metric}] value must be finite.`);\n  }\n  return { type: HavingExpressionType.CONDITION, metric, operator, value };\n}\n\nfunction logical(\n  type: HavingExpressionType.AND | HavingExpressionType.OR,\n  operands: readonly HavingExpression[],\n): HavingExpression {\n  const [first, ...rest] = operands;\n  if (first === undefined) {\n    throw new TypeError(`having ${type} operands must not be empty.`);\n  }\n  return { type, operands: [first, ...rest] };\n}\n\nexport const havingDsl: HavingDsl = {\n  eq: (metric, value) => condition(ComparisonOperator.EQ, metric, value),\n  ne: (metric, value) => condition(ComparisonOperator.NE, metric, value),\n  gt: (metric, value) => condition(ComparisonOperator.GT, metric, value),\n  gte: (metric, value) => condition(ComparisonOperator.GTE, metric, value),\n  lt: (metric, value) => condition(ComparisonOperator.LT, metric, value),\n  lte: (metric, value) => condition(ComparisonOperator.LTE, metric, value),\n  between(metric, lower, upper) {\n    if (!Number.isFinite(lower) || !Number.isFinite(upper)) {\n      throw new TypeError(`having between [${metric}] bounds must be finite.`);\n    }\n    if (lower > upper) {\n      throw new TypeError(\n        `having between [${metric}] lower bound must not exceed upper bound.`,\n      );\n    }\n    return { type: HavingExpressionType.BETWEEN, metric, lower, upper };\n  },\n  isIn(metric, values) {\n    const [first, ...rest] = values;\n    if (first === undefined) {\n      throw new TypeError(`having in [${metric}] values must not be empty.`);\n    }\n    if (!values.every(Number.isFinite)) {\n      throw new TypeError(`having in [${metric}] values must be finite.`);\n    }\n    return { type: HavingExpressionType.IN, metric, values: [first, ...rest] };\n  },\n  isNull: metric => ({ type: HavingExpressionType.IS_NULL, metric }),\n  isNotNull: metric => ({\n    type: HavingExpressionType.IS_NULL,\n    metric,\n    negated: true,\n  }),\n  and: operands => logical(HavingExpressionType.AND, operands),\n  or: operands => logical(HavingExpressionType.OR, operands),\n};\n"],"mappings":";;AAgHA,SAASA,EACP,GACA,GACA,GACkB;CAClB,IAAI,CAAC,OAAO,SAASC,CAAK,GACxB,MAAU,UAAU,qBAAqBC,EAAO,wBAAwB;CAE1E,OAAO;EAAE,MAAMC,EAAqB;EAAW;EAAQ;EAAU;CAAM;AACzE;AAEA,SAASC,EACP,GACA,GACkB;CAClB,IAAM,CAACC,GAAO,GAAGC,KAAQC;CACzB,IAAIF,MAAU,KAAA,GACZ,MAAU,UAAU,UAAUG,EAAK,6BAA6B;CAElE,OAAO;EAAE;EAAM,UAAU,CAACH,GAAO,GAAGC,CAAI;CAAE;AAC5C;AAEA,IAAaG,IAAuB;CAClC,KAAK,GAAQ,MAAUT,EAAUU,EAAmB,IAAIR,GAAQD,CAAK;CACrE,KAAK,GAAQ,MAAUD,EAAUU,EAAmB,IAAIR,GAAQD,CAAK;CACrE,KAAK,GAAQ,MAAUD,EAAUU,EAAmB,IAAIR,GAAQD,CAAK;CACrE,MAAM,GAAQ,MAAUD,EAAUU,EAAmB,KAAKR,GAAQD,CAAK;CACvE,KAAK,GAAQ,MAAUD,EAAUU,EAAmB,IAAIR,GAAQD,CAAK;CACrE,MAAM,GAAQ,MAAUD,EAAUU,EAAmB,KAAKR,GAAQD,CAAK;CACvE,QAAQ,GAAQ,GAAO,GAAO;EAC5B,IAAI,CAAC,OAAO,SAASU,CAAK,KAAK,CAAC,OAAO,SAASC,CAAK,GACnD,MAAU,UAAU,mBAAmBV,EAAO,yBAAyB;EAEzE,IAAIS,IAAQC,GACV,MAAU,UACR,mBAAmBV,EAAO,2CAC5B;EAEF,OAAO;GAAE,MAAMC,EAAqB;GAAS;GAAQ;GAAO;EAAM;CACpE;CACA,KAAK,GAAQ,GAAQ;EACnB,IAAM,CAACE,GAAO,GAAGC,KAAQO;EACzB,IAAIR,MAAU,KAAA,GACZ,MAAU,UAAU,cAAcH,EAAO,4BAA4B;EAEvE,IAAI,CAACW,EAAO,MAAM,OAAO,QAAQ,GAC/B,MAAU,UAAU,cAAcX,EAAO,yBAAyB;EAEpE,OAAO;GAAE,MAAMC,EAAqB;GAAI;GAAQ,QAAQ,CAACE,GAAO,GAAGC,CAAI;EAAE;CAC3E;CACA,SAAQ,OAAW;EAAE,MAAMH,EAAqB;EAAS;CAAO;CAChE,YAAW,OAAW;EACpB,MAAMA,EAAqB;EAC3B;EACA,SAAS;CACX;CACA,MAAK,MAAYC,EAAQD,EAAqB,KAAKI,CAAQ;CAC3D,KAAI,MAAYH,EAAQD,EAAqB,IAAII,CAAQ;AAC3D"}

package/dist/dsl/aggregation/index.d.cts

@@ -0,0 +1,4 @@
+export * from './types.cjs';
+export { aggregation } from './builders.cjs';
+export type { DerivedExpressionDsl } from './derived.cjs';
+export type { HavingDsl } from './having.cjs';

package/dist/dsl/aggregation/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types.js';
+export { aggregation } from './builders.js';
+export type { DerivedExpressionDsl } from './derived.js';
+export type { HavingDsl } from './having.js';

package/dist/dsl/aggregation/sort.cjs

@@ -0,0 +1,2 @@
+const e=require("../sort.cjs");function t(t){let n=[...t.sort??[]],r=new Set(n.map(e=>e.field));return[...n,...(t.groupBy??[]).map(e=>e.alias).filter(e=>!r.has(e)).map(e.asc)]}exports.effectiveSort=t;
+//# sourceMappingURL=sort.cjs.map

package/dist/dsl/aggregation/sort.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort.cjs","names":["asc","require_sort","effectiveSort","sort","query","sorted","entry","group","alias"],"sources":["../../../src/dsl/aggregation/sort.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 dsl/aggregation/index.ts.\nimport type { AggregationQuery } from './types.js';\nimport { asc, type FieldSort } from '../sort.js';\n\n/**\n * The sort Wow actually applies: what the query asked for, then each remaining\n * group ascending, so a page of grouped rows has one stable order.\n */\nexport function effectiveSort<FIELDS extends string = string>(\n  query: Pick<AggregationQuery<string, FIELDS>, 'groupBy' | 'sort'>,\n): FieldSort[] {\n  const sort = [...(query.sort ?? [])];\n  const sorted = new Set(sort.map(entry => entry.field));\n  return [\n    ...sort,\n    ...(query.groupBy ?? [])\n      .map(group => group.alias)\n      .filter(alias => !sorted.has(alias))\n      .map(asc),\n  ];\n}\n"],"mappings":"+BAqBA,SAAgBE,EACd,EACa,CACb,IAAMC,EAAO,CAAC,GAAIC,EAAM,MAAQ,CAAC,CAAE,EAC7BC,EAAS,IAAI,IAAIF,EAAK,IAAI,GAASG,EAAM,KAAK,CAAC,EACrD,MAAO,CACL,GAAGH,EACH,IAAIC,EAAM,SAAW,CAAC,EAAA,CACnB,IAAI,GAASG,EAAM,KAAK,CAAC,CACzB,OAAO,GAAS,CAACF,EAAO,IAAIG,CAAK,CAAC,CAAC,CACnC,IAAIR,EAAAA,GAAG,CACZ,CACF"}

package/dist/dsl/aggregation/sort.d.cts

@@ -0,0 +1,7 @@
+import { AggregationQuery } from './types.cjs';
+import { FieldSort } from '../sort.cjs';
+/**
+ * The sort Wow actually applies: what the query asked for, then each remaining
+ * group ascending, so a page of grouped rows has one stable order.
+ */
+export declare function effectiveSort<FIELDS extends string = string>(query: Pick<AggregationQuery<string, FIELDS>, 'groupBy' | 'sort'>): FieldSort[];

package/dist/dsl/aggregation/sort.d.ts

@@ -0,0 +1,7 @@
+import { AggregationQuery } from './types.js';
+import { FieldSort } from '../sort.js';
+/**
+ * The sort Wow actually applies: what the query asked for, then each remaining
+ * group ascending, so a page of grouped rows has one stable order.
+ */
+export declare function effectiveSort<FIELDS extends string = string>(query: Pick<AggregationQuery<string, FIELDS>, 'groupBy' | 'sort'>): FieldSort[];

package/dist/dsl/aggregation/sort.es.js

@@ -0,0 +1,10 @@
+import { asc as e } from "../sort.es.js";
+//#region src/dsl/aggregation/sort.ts
+function t(t) {
+	let n = [...t.sort ?? []], r = new Set(n.map((e) => e.field));
+	return [...n, ...(t.groupBy ?? []).map((e) => e.alias).filter((e) => !r.has(e)).map(e)];
+}
+//#endregion
+export { t as effectiveSort };
+
+//# sourceMappingURL=sort.es.js.map

package/dist/dsl/aggregation/sort.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort.es.js","names":["effectiveSort","sort","query","sorted","entry","group","alias","asc"],"sources":["../../../src/dsl/aggregation/sort.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 dsl/aggregation/index.ts.\nimport type { AggregationQuery } from './types.js';\nimport { asc, type FieldSort } from '../sort.js';\n\n/**\n * The sort Wow actually applies: what the query asked for, then each remaining\n * group ascending, so a page of grouped rows has one stable order.\n */\nexport function effectiveSort<FIELDS extends string = string>(\n  query: Pick<AggregationQuery<string, FIELDS>, 'groupBy' | 'sort'>,\n): FieldSort[] {\n  const sort = [...(query.sort ?? [])];\n  const sorted = new Set(sort.map(entry => entry.field));\n  return [\n    ...sort,\n    ...(query.groupBy ?? [])\n      .map(group => group.alias)\n      .filter(alias => !sorted.has(alias))\n      .map(asc),\n  ];\n}\n"],"mappings":";;AAqBA,SAAgBA,EACd,GACa;CACb,IAAMC,IAAO,CAAC,GAAIC,EAAM,QAAQ,CAAC,CAAE,GAC7BC,IAAS,IAAI,IAAIF,EAAK,KAAI,MAASG,EAAM,KAAK,CAAC;CACrD,OAAO,CACL,GAAGH,GACH,IAAIC,EAAM,WAAW,CAAC,EAAA,CACnB,KAAI,MAASG,EAAM,KAAK,CAAC,CACzB,QAAO,MAAS,CAACF,EAAO,IAAIG,CAAK,CAAC,CAAC,CACnC,IAAIC,CAAG,CACZ;AACF"}

package/dist/dsl/aggregation/types.cjs

@@ -0,0 +1,2 @@
+var e=function(e){return e.TERMS=`TERMS`,e.HISTOGRAM=`HISTOGRAM`,e.DATE_HISTOGRAM=`DATE_HISTOGRAM`,e.DATE_PART=`DATE_PART`,e}({}),t=function(e){return e.COUNT=`COUNT`,e.NUMERIC=`NUMERIC`,e.ANY=`ANY`,e.DISTINCT_COUNT=`DISTINCT_COUNT`,e.PERCENTILE=`PERCENTILE`,e.DERIVED=`DERIVED`,e.FIRST=`FIRST`,e.LAST=`LAST`,e}({}),n=function(e){return e.FIELD=`FIELD`,e.CONSTANT=`CONSTANT`,e.BINARY=`BINARY`,e.DATE_DIFF=`DATE_DIFF`,e}({}),r=function(e){return e.SECOND=`SECOND`,e.MINUTE=`MINUTE`,e.HOUR=`HOUR`,e.DAY=`DAY`,e}({}),i=function(e){return e.ADD=`ADD`,e.SUBTRACT=`SUBTRACT`,e.MULTIPLY=`MULTIPLY`,e.DIVIDE=`DIVIDE`,e}({}),a=function(e){return e.YEAR=`YEAR`,e.QUARTER=`QUARTER`,e.MONTH=`MONTH`,e.WEEK=`WEEK`,e.DAY=`DAY`,e.HOUR=`HOUR`,e.MINUTE=`MINUTE`,e.SECOND=`SECOND`,e}({}),o=function(e){return e.DAY_OF_WEEK=`DAY_OF_WEEK`,e.DAY_OF_MONTH=`DAY_OF_MONTH`,e.HOUR_OF_DAY=`HOUR_OF_DAY`,e.MONTH_OF_YEAR=`MONTH_OF_YEAR`,e}({}),s=function(e){return e.SUM=`SUM`,e.AVG=`AVG`,e.MIN=`MIN`,e.MAX=`MAX`,e.STDDEV=`STDDEV`,e.VARIANCE=`VARIANCE`,e}({}),c=function(e){return e.METRIC_REF=`METRIC_REF`,e.CONSTANT=`CONSTANT`,e.BINARY=`BINARY`,e}({}),l=function(e){return e.CONDITION=`CONDITION`,e.BETWEEN=`BETWEEN`,e.IN=`IN`,e.IS_NULL=`IS_NULL`,e.AND=`AND`,e.OR=`OR`,e}({}),u=function(e){return e.EQ=`EQ`,e.NE=`NE`,e.GT=`GT`,e.GTE=`GTE`,e.LT=`LT`,e.LTE=`LTE`,e}({}),d=Object.freeze({DEFAULT_LIMIT:100,MAX_LIMIT:1e4,MAX_ELEMENTS:5,MAX_GROUPS:32,MAX_METRICS:64,MAX_SORT_FIELDS:32,MAX_EXPRESSION_DEPTH:8,MAX_EXPRESSION_NODES:256});exports.AGGREGATION_LIMITS=d,exports.AggregationDatePart=o,exports.AggregationDateUnit=a,exports.AggregationExpressionOperator=i,exports.AggregationExpressionType=n,exports.AggregationFunction=s,exports.AggregationGroupType=e,exports.AggregationMetricType=t,exports.ComparisonOperator=u,exports.DateDiffUnit=r,exports.DerivedExpressionType=c,exports.HavingExpressionType=l;
+//# sourceMappingURL=types.cjs.map

package/dist/dsl/aggregation/types.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.cjs","names":["AggregationGroupType","\"TERMS\"","\"HISTOGRAM\"","\"DATE_HISTOGRAM\"","\"DATE_PART\"","AggregationMetricType","\"COUNT\"","\"NUMERIC\"","\"ANY\"","\"DISTINCT_COUNT\"","\"PERCENTILE\"","\"DERIVED\"","\"FIRST\"","\"LAST\"","AggregationExpressionType","\"FIELD\"","\"CONSTANT\"","\"BINARY\"","\"DATE_DIFF\"","DateDiffUnit","\"SECOND\"","\"MINUTE\"","\"HOUR\"","\"DAY\"","AggregationExpressionOperator","\"ADD\"","\"SUBTRACT\"","\"MULTIPLY\"","\"DIVIDE\"","AggregationDateUnit","\"YEAR\"","\"QUARTER\"","\"MONTH\"","\"WEEK\"","AggregationDatePart","\"DAY_OF_WEEK\"","\"DAY_OF_MONTH\"","\"HOUR_OF_DAY\"","\"MONTH_OF_YEAR\"","AggregationFunction","\"SUM\"","\"AVG\"","\"MIN\"","\"MAX\"","\"STDDEV\"","\"VARIANCE\"","DerivedExpressionType","\"METRIC_REF\"","HavingExpressionType","\"CONDITION\"","\"BETWEEN\"","\"IN\"","\"IS_NULL\"","\"AND\"","\"OR\"","ComparisonOperator","\"EQ\"","\"NE\"","\"GT\"","\"GTE\"","\"LT\"","\"LTE\"","AGGREGATION_LIMITS"],"sources":["../../../src/dsl/aggregation/types.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\nimport type {\n  ElementFilterExpression,\n  FilterExpression,\n  QueryField,\n  ExpressionFilter,\n} from '../filter/index.js';\nimport type { FieldSort } from '../sort.js';\n\n/** The kind of an {@link AggregationGroup}, sent as its `type`. */\nexport enum AggregationGroupType {\n  /** One group per distinct value; {@link aggregation.terms}. */\n  TERMS = 'TERMS',\n  /** Number buckets of equal width; {@link aggregation.histogram}. */\n  HISTOGRAM = 'HISTOGRAM',\n  /** Calendar buckets of a time field; {@link aggregation.dateHistogram}. */\n  DATE_HISTOGRAM = 'DATE_HISTOGRAM',\n  /**\n   * One calendar part of a time field, such as the weekday or the hour;\n   * {@link aggregation.datePart}. Wow 9.2 and later.\n   */\n  DATE_PART = 'DATE_PART',\n}\n\n/**\n * The kind of an {@link AggregationMetric}, sent as its `type`. Wow 8.12\n * knows `COUNT` and `NUMERIC`, Wow 9.0 adds `ANY`, and the other three need\n * Wow 9.1.\n */\nexport enum AggregationMetricType {\n  /** The number of rows; {@link aggregation.count}. */\n  COUNT = 'COUNT',\n  /**\n   * An {@link AggregationFunction} of an expression; {@link aggregation.sum}\n   * and its siblings.\n   */\n  NUMERIC = 'NUMERIC',\n  /** Any one value of a field; {@link aggregation.any}. Wow 9.0 and later. */\n  ANY = 'ANY',\n  /**\n   * The number of distinct values; {@link aggregation.distinctCount}. Wow 9.1\n   * and later.\n   */\n  DISTINCT_COUNT = 'DISTINCT_COUNT',\n  /**\n   * A percentile of an expression; {@link aggregation.percentile}. Wow 9.1\n   * and later.\n   */\n  PERCENTILE = 'PERCENTILE',\n  /**\n   * Arithmetic over other metrics; {@link aggregation.derived}. Wow 9.1 and\n   * later.\n   */\n  DERIVED = 'DERIVED',\n  /**\n   * A field's value on the group's earliest record; {@link aggregation.first}.\n   * Wow 9.2 and later.\n   */\n  FIRST = 'FIRST',\n  /**\n   * A field's value on the group's latest record; {@link aggregation.last}.\n   * Wow 9.2 and later.\n   */\n  LAST = 'LAST',\n}\n\n/** The kind of an {@link AggregationExpression} node, sent as its `type`. */\nexport enum AggregationExpressionType {\n  /** The value of a field; {@link aggregation.field}. */\n  FIELD = 'FIELD',\n  /** A number; {@link aggregation.constant}. */\n  CONSTANT = 'CONSTANT',\n  /** Two operands and an {@link AggregationExpressionOperator}. */\n  BINARY = 'BINARY',\n  /**\n   * The time elapsed between two time fields; {@link aggregation.dateDiff}.\n   * Wow 9.2 and later.\n   */\n  DATE_DIFF = 'DATE_DIFF',\n}\n\n/**\n * The unit a `DATE_DIFF` measures elapsed time in. Each has a fixed length:\n * a `DAY` is exactly 24 hours, and months and years, whose length depends on\n * a calendar and a time zone, are not offered.\n */\nexport enum DateDiffUnit {\n  SECOND = 'SECOND',\n  MINUTE = 'MINUTE',\n  HOUR = 'HOUR',\n  DAY = 'DAY',\n}\n\n/**\n * The arithmetic of a `BINARY` node, in an {@link AggregationExpression} or a\n * {@link DerivedExpression}.\n */\nexport enum AggregationExpressionOperator {\n  /** `left + right` */\n  ADD = 'ADD',\n  /** `left - right` */\n  SUBTRACT = 'SUBTRACT',\n  /** `left * right` */\n  MULTIPLY = 'MULTIPLY',\n  /** `left / right` */\n  DIVIDE = 'DIVIDE',\n}\n\n/**\n * The calendar unit of a `DATE_HISTOGRAM` bucket, cut in the group's\n * `timeZone`.\n */\nexport enum AggregationDateUnit {\n  YEAR = 'YEAR',\n  QUARTER = 'QUARTER',\n  MONTH = 'MONTH',\n  WEEK = 'WEEK',\n  DAY = 'DAY',\n  HOUR = 'HOUR',\n  MINUTE = 'MINUTE',\n  SECOND = 'SECOND',\n}\n\n/**\n * The calendar part a `DATE_PART` group takes of each instant, read in the\n * group's `timeZone`. Its keys are integers from a fixed domain, so records\n * from different days, weeks or years fall into one bucket.\n */\nexport enum AggregationDatePart {\n  /** The ISO weekday: 1 is Monday, 7 is Sunday. */\n  DAY_OF_WEEK = 'DAY_OF_WEEK',\n  /**\n   * The day of the month, 1 to 31; days 29 to 31 exist only in the months\n   * that have them.\n   */\n  DAY_OF_MONTH = 'DAY_OF_MONTH',\n  /** The hour on the wall clock of the group's `timeZone`, 0 to 23. */\n  HOUR_OF_DAY = 'HOUR_OF_DAY',\n  /** The month of the year, 1 (January) to 12. */\n  MONTH_OF_YEAR = 'MONTH_OF_YEAR',\n}\n\n/**\n * What a `NUMERIC` metric computes over its expression; each has a builder,\n * {@link aggregation.sum} through {@link aggregation.variance}.\n */\nexport enum AggregationFunction {\n  /** The sum */\n  SUM = 'SUM',\n  /** The average */\n  AVG = 'AVG',\n  /** The least value */\n  MIN = 'MIN',\n  /** The greatest value */\n  MAX = 'MAX',\n  /** The standard deviation */\n  STDDEV = 'STDDEV',\n  /** The variance */\n  VARIANCE = 'VARIANCE',\n}\n\n/**\n * An array field whose elements the query aggregates over instead of the\n * root documents; build it with {@link aggregation.element}. A query takes at\n * most `AGGREGATION_LIMITS.MAX_ELEMENTS` of them.\n */\nexport interface AggregationElement {\n  /** The array field, a query field path. */\n  path: QueryField;\n  /**\n   * Keeps only the elements that match; no root filters and no search, but\n   * an `EXPRESSION` filter may compare an element's computed value.\n   */\n  filter?: ElementFilterExpression | ExpressionFilter;\n}\n\n/** What every {@link AggregationGroup} has. */\ninterface AggregationGroupBase<FIELDS extends string = string> {\n  /** The field the rows are grouped by. */\n  field: QueryField<FIELDS>;\n  /** The name of the group's column in the result rows. */\n  alias: string;\n}\n\n/**\n * What a TERMS or HISTOGRAM group groups by: a field, or a computed\n * expression in its place (Wow 9.2 and later), never both. An expression\n * input is an expensive computation the server admits only where\n * `analysis.expressions` is `true`.\n */\nexport type AggregationGroupInput<FIELDS extends string = string> =\n  | {\n      /** The field the rows are grouped by. */\n      field: QueryField<FIELDS>;\n      expression?: undefined;\n    }\n  | {\n      field?: undefined;\n      /** The per-row value the rows are grouped by, such as a `DATE_DIFF`. */\n      expression: AggregationExpression<FIELDS>;\n    };\n\n/**\n * One group per distinct value of a field, or of an expression;\n * {@link aggregation.terms}. `missingKey` needs a field.\n */\nexport type TermsAggregationGroup<FIELDS extends string = string> = {\n  type: AggregationGroupType.TERMS;\n  /** The name of the group's column in the result rows. */\n  alias: string;\n  /** The key the rows without a value are grouped under. Wow 9.1 and later. */\n  missingKey?: string;\n} & AggregationGroupInput<FIELDS>;\n\n/**\n * Buckets of equal width over a number field, or over an expression;\n * {@link aggregation.histogram}.\n */\nexport type HistogramAggregationGroup<FIELDS extends string = string> = {\n  type: AggregationGroupType.HISTOGRAM;\n  /** The name of the group's column in the result rows. */\n  alias: string;\n  /** The width of each bucket, greater than 0. */\n  interval: number;\n} & AggregationGroupInput<FIELDS>;\n\n/**\n * Calendar buckets over a time field in epoch milliseconds;\n * {@link aggregation.dateHistogram}.\n */\nexport interface DateHistogramAggregationGroup<\n  FIELDS extends string = string,\n> extends AggregationGroupBase<FIELDS> {\n  type: AggregationGroupType.DATE_HISTOGRAM;\n  /** The calendar unit of each bucket. */\n  unit: AggregationDateUnit;\n  /** The IANA zone the buckets are cut in; `UTC` when absent. */\n  timeZone?: string;\n  /**\n   * Whether the server fills in the empty buckets of the range. Wow 9.1 and\n   * later, and only when this is the query's only group.\n   */\n  dense?: boolean;\n}\n\n/**\n * One calendar part of a time field in epoch milliseconds, such as the\n * weekday or the hour; {@link aggregation.datePart}. Its keys in the result\n * rows are integers from the part's domain, such as 1 (Monday) to 7 (Sunday)\n * for `DAY_OF_WEEK`. Wow 9.2 and later.\n */\nexport interface DatePartAggregationGroup<\n  FIELDS extends string = string,\n> extends AggregationGroupBase<FIELDS> {\n  type: AggregationGroupType.DATE_PART;\n  /** The calendar part each row is grouped by. */\n  part: AggregationDatePart;\n  /** The IANA zone the part is read in; `UTC` when absent. */\n  timeZone?: string;\n  /**\n   * Whether the server returns every key of the part's domain, filling a\n   * key with no records with each metric's empty value. Only when this is\n   * the query's only group.\n   */\n  dense?: boolean;\n}\n\n/**\n * One dimension of an {@link AggregationQuery}'s `groupBy`: each result row\n * is one combination of the groups' keys.\n */\nexport type AggregationGroup<FIELDS extends string = string> =\n  | TermsAggregationGroup<FIELDS>\n  | HistogramAggregationGroup<FIELDS>\n  | DateHistogramAggregationGroup<FIELDS>\n  | DatePartAggregationGroup<FIELDS>;\n\n/** The value of a field, as an operand; {@link aggregation.field}. */\nexport interface FieldAggregationExpression<FIELDS extends string = string> {\n  type: AggregationExpressionType.FIELD;\n  /** The field, a query field path. */\n  field: QueryField<FIELDS>;\n}\n\n/** A number, as an operand; {@link aggregation.constant}. */\nexport interface ConstantAggregationExpression {\n  type: AggregationExpressionType.CONSTANT;\n  /** A finite number. */\n  value: number;\n}\n\n/**\n * `left operator right`; {@link aggregation.add}, {@link aggregation.subtract},\n * {@link aggregation.multiply}, {@link aggregation.divide}.\n */\nexport interface BinaryAggregationExpression<FIELDS extends string = string> {\n  type: AggregationExpressionType.BINARY;\n  /** The arithmetic. */\n  operator: AggregationExpressionOperator;\n  /** The left operand. */\n  left: AggregationExpression<FIELDS>;\n  /** The right operand. */\n  right: AggregationExpression<FIELDS>;\n}\n\n/**\n * The time from the instant in `from` to the instant in `to`, `to − from`,\n * in `unit`, as a signed decimal: negative when `to` is earlier, and no\n * value when either is absent. Both are single-valued time fields (their\n * `aggregate.groups` list `DATE_HISTOGRAM`), each read in its own encoding;\n * {@link aggregation.dateDiff}. Wow 9.2 and later.\n */\nexport interface DateDiffAggregationExpression<FIELDS extends string = string> {\n  type: AggregationExpressionType.DATE_DIFF;\n  /** The earlier instant, when the difference is positive. */\n  from: QueryField<FIELDS>;\n  /** The later instant, when the difference is positive. */\n  to: QueryField<FIELDS>;\n  /** The unit the difference is measured in. */\n  unit: DateDiffUnit;\n}\n\n/**\n * Per-row arithmetic over fields, time differences and numbers, which a\n * metric aggregates, a TERMS or HISTOGRAM group groups by, and an\n * `EXPRESSION` filter compares. A tree at most\n * `AGGREGATION_LIMITS.MAX_EXPRESSION_DEPTH` deep and `MAX_EXPRESSION_NODES`\n * large, counted over a query's metrics together and over each group or\n * filter on its own.\n */\nexport type AggregationExpression<FIELDS extends string = string> =\n  | FieldAggregationExpression<FIELDS>\n  | ConstantAggregationExpression\n  | BinaryAggregationExpression<FIELDS>\n  | DateDiffAggregationExpression<FIELDS>;\n\n/** The number of rows in each group; {@link aggregation.count}. */\nexport interface CountAggregationMetric<FIELDS extends string = string> {\n  /** Counts only the rows that match. Wow 9.1 and later. */\n  filter?: FilterExpression<FIELDS>;\n  type: AggregationMetricType.COUNT;\n  /** The name of the metric's column in the result rows. */\n  alias: string;\n}\n\n/**\n * An {@link AggregationFunction} of an expression; {@link aggregation.sum},\n * `avg`, `min`, `max`, `stddev`, `variance`.\n */\nexport interface NumericAggregationMetric<FIELDS extends string = string> {\n  /** Aggregates only the rows that match. Wow 9.1 and later. */\n  filter?: FilterExpression<FIELDS>;\n  type: AggregationMetricType.NUMERIC;\n  /** What is computed. */\n  function: AggregationFunction;\n  /** The per-row value it is computed over. */\n  expression: AggregationExpression<FIELDS>;\n  /** The name of the metric's column in the result rows. */\n  alias: string;\n}\n\n/**\n * Any one value of a field within each group, of any type;\n * {@link aggregation.any}. Wow 9.0 and later. Neither a derived metric nor\n * `having` may refer to it.\n */\nexport interface AnyAggregationMetric<FIELDS extends string = string> {\n  /** Aggregates only the rows that match. Wow 9.1 and later. */\n  filter?: FilterExpression<FIELDS>;\n  type: AggregationMetricType.ANY;\n  /** The field whose value is taken. */\n  field: QueryField<FIELDS>;\n  /** The name of the metric's column in the result rows. */\n  alias: string;\n}\n\n/**\n * A field's value on the earliest (`FIRST`) or latest (`LAST`) record of\n * each group, ordered by `orderBy`; {@link aggregation.first} and\n * {@link aggregation.last}. Wow 9.2 and later.\n *\n * The value comes back in the field's own type, not as a number, and is\n * `null` when no record of the group has both a value and an `orderBy`\n * position. Without `orderBy` the server orders by the model's event time,\n * the field the descriptor names as `analysis.firstLastOrderBy`. Records\n * tied on `orderBy` may yield any one of their values. Like `ANY`, neither a\n * derived metric nor `having` may refer to it.\n */\nexport interface EdgeAggregationMetric<FIELDS extends string = string> {\n  type: AggregationMetricType.FIRST | AggregationMetricType.LAST;\n  /** The single-valued field whose value is taken. */\n  field: QueryField<FIELDS>;\n  /**\n   * The single-valued, sortable field that orders the records; the model's\n   * event time when absent.\n   */\n  orderBy?: QueryField<FIELDS>;\n  /** The name of the metric's column in the result rows. */\n  alias: string;\n  /** Aggregates only the rows that match. */\n  filter?: FilterExpression<FIELDS>;\n}\n\n/**\n * The number of distinct values of an expression;\n * {@link aggregation.distinctCount}. Wow 9.1 and later.\n */\nexport interface DistinctCountAggregationMetric<\n  FIELDS extends string = string,\n> {\n  type: AggregationMetricType.DISTINCT_COUNT;\n  /** The per-row value whose distinct values are counted. */\n  expression: AggregationExpression<FIELDS>;\n  /** The name of the metric's column in the result rows. */\n  alias: string;\n  /** Aggregates only the rows that match. */\n  filter?: FilterExpression<FIELDS>;\n}\n\n/**\n * A percentile of an expression; {@link aggregation.percentile}. Wow 9.1 and\n * later.\n */\nexport interface PercentileAggregationMetric<FIELDS extends string = string> {\n  type: AggregationMetricType.PERCENTILE;\n  /** The per-row value the percentile is taken over. */\n  expression: AggregationExpression<FIELDS>;\n  /** Which percentile, within (0, 100). */\n  percentile: number;\n  /** The name of the metric's column in the result rows. */\n  alias: string;\n  /** Aggregates only the rows that match. */\n  filter?: FilterExpression<FIELDS>;\n}\n\n/** The kind of a {@link DerivedExpression} node, sent as its `type`. */\nexport enum DerivedExpressionType {\n  /** The value of another metric of the row, by its alias. */\n  METRIC_REF = 'METRIC_REF',\n  /** A number. */\n  CONSTANT = 'CONSTANT',\n  /** Two operands and an {@link AggregationExpressionOperator}. */\n  BINARY = 'BINARY',\n}\n\n/**\n * Post-aggregation arithmetic; references must name earlier metrics that are\n * not `ANY`, `FIRST` or `LAST`.\n */\nexport type DerivedExpression =\n  | { type: DerivedExpressionType.METRIC_REF; metric: string }\n  | { type: DerivedExpressionType.CONSTANT; value: number }\n  | {\n      type: DerivedExpressionType.BINARY;\n      operator: AggregationExpressionOperator;\n      left: DerivedExpression;\n      right: DerivedExpression;\n    };\n\n/**\n * A metric computed from metrics declared before it in the same query, after\n * aggregation; {@link aggregation.derived}. Wow 9.1 and later.\n */\nexport interface DerivedAggregationMetric {\n  type: AggregationMetricType.DERIVED;\n  /** The arithmetic over the other metrics. */\n  expression: DerivedExpression;\n  /** The name of the metric's column in the result rows. */\n  alias: string;\n}\n\n/** The kind of a {@link HavingExpression} node, sent as its `type`. */\nexport enum HavingExpressionType {\n  /** A metric compared with a number; `aggregation.having.eq` … `lte`. */\n  CONDITION = 'CONDITION',\n  /** A metric within bounds, inclusive; `aggregation.having.between`. */\n  BETWEEN = 'BETWEEN',\n  /** A metric equal to one of the numbers; `aggregation.having.isIn`. */\n  IN = 'IN',\n  /**\n   * A metric without a value, or with one when `negated`;\n   * `aggregation.having.isNull`, `isNotNull`.\n   */\n  IS_NULL = 'IS_NULL',\n  /** All operands hold; `aggregation.having.and`. */\n  AND = 'AND',\n  /** At least one operand holds; `aggregation.having.or`. */\n  OR = 'OR',\n}\n\n/** The comparison of a `CONDITION` in a {@link HavingExpression}. */\nexport enum ComparisonOperator {\n  /** `=` */\n  EQ = 'EQ',\n  /** `≠` */\n  NE = 'NE',\n  /** `>` */\n  GT = 'GT',\n  /** `≥` */\n  GTE = 'GTE',\n  /** `<` */\n  LT = 'LT',\n  /** `≤` */\n  LTE = 'LTE',\n}\n\n/**\n * Filters grouped results by metric aliases, before sorting/limit; never an\n * `ANY`, `FIRST` or `LAST` metric.\n */\nexport type HavingExpression =\n  | {\n      type: HavingExpressionType.CONDITION;\n      metric: string;\n      operator: ComparisonOperator;\n      value: number;\n    }\n  | {\n      type: HavingExpressionType.BETWEEN;\n      metric: string;\n      lower: number;\n      upper: number;\n    }\n  | {\n      type: HavingExpressionType.IN;\n      metric: string;\n      values: [number, ...number[]];\n    }\n  | { type: HavingExpressionType.IS_NULL; metric: string; negated?: boolean }\n  | {\n      type: HavingExpressionType.AND | HavingExpressionType.OR;\n      operands: [HavingExpression, ...HavingExpression[]];\n    };\n\n/**\n * One column an {@link AggregationQuery} computes for each group; a query\n * takes 1 to `AGGREGATION_LIMITS.MAX_METRICS` of them.\n */\nexport type AggregationMetric<FIELDS extends string = string> =\n  | CountAggregationMetric<FIELDS>\n  | NumericAggregationMetric<FIELDS>\n  | AnyAggregationMetric<FIELDS>\n  | DistinctCountAggregationMetric<FIELDS>\n  | PercentileAggregationMetric<FIELDS>\n  | DerivedAggregationMetric\n  | EdgeAggregationMetric<FIELDS>;\n\n/**\n * An aggregation request: which documents, grouped how, computing which\n * metrics. `QueryApi.aggregate` and `aggregateStream` send it, and each\n * result row holds the groups' and metrics' columns by alias. Assemble it\n * with {@link aggregation.query}, which checks the rules Wow enforces across\n * its parts before anything is sent.\n *\n * Wow 8.11 has no aggregation endpoint; Wow 8.12 added it with `COUNT` and\n * `NUMERIC` metrics, and Wow 9.0 added `ANY`. `having`, the `DISTINCT_COUNT`,\n * `PERCENTILE` and `DERIVED` metrics, metric filters, `missingKey` and `dense`\n * need Wow 9.1.\n *\n * @template ROOT_FIELDS - The fields `filter` may name\n * @template AGGREGATION_FIELDS - The fields groups and metrics may name\n */\nexport interface AggregationQuery<\n  ROOT_FIELDS extends string = string,\n  AGGREGATION_FIELDS extends string = ROOT_FIELDS,\n> {\n  /** Which documents are aggregated; all of them when absent. */\n  filter?: FilterExpression<ROOT_FIELDS>;\n  /** Array fields to aggregate the elements of, instead of the documents. */\n  elements?: AggregationElement[];\n  /** The dimensions of the result; one row in total when absent or empty. */\n  groupBy?: AggregationGroup<AGGREGATION_FIELDS>[];\n  /** The columns computed for each group. */\n  metrics: [\n    AggregationMetric<AGGREGATION_FIELDS>,\n    ...AggregationMetric<AGGREGATION_FIELDS>[],\n  ];\n  /**\n   * The order of the rows, by group or metric alias; needs a `groupBy`. Wow\n   * then sorts by each remaining group ascending.\n   */\n  sort?: FieldSort[];\n  /**\n   * The most rows returned, 1 to `AGGREGATION_LIMITS.MAX_LIMIT`; the\n   * server returns `DEFAULT_LIMIT` (100) when absent.\n   */\n  limit?: number;\n  /**\n   * Keeps only the grouped rows whose metrics match, before `sort` and\n   * `limit`; built with {@link aggregation.having}. Needs a `groupBy`.\n   */\n  having?: HavingExpression;\n}\n\n/**\n * The options every metric builder takes after its target and alias.\n */\nexport interface AggregationMetricOptions<FIELDS extends string = string> {\n  /** Counts only the rows that match; sent as the metric's `filter`. */\n  filter?: FilterExpression<FIELDS>;\n}\n\n/** The options of {@link aggregation.terms}. */\nexport interface TermsAggregationOptions {\n  /** The key rows without a value are grouped under; must not be blank. */\n  missingKey?: string;\n}\n\n/** The options of {@link aggregation.histogram}. */\nexport interface HistogramAggregationOptions {\n  /** The width of each bucket: finite and greater than 0. */\n  interval: number;\n}\n\n/** The options of {@link aggregation.dateHistogram}. */\nexport interface DateHistogramAggregationOptions {\n  /** The calendar unit of each bucket. */\n  unit: AggregationDateUnit;\n  /** The zone the buckets are cut in, an IANA id. Defaults to `UTC`. */\n  timeZone?: string;\n  /**\n   * Whether the server fills in the empty buckets of the range. Only when\n   * this is the only group.\n   */\n  dense?: boolean;\n}\n\n/** The options of {@link aggregation.datePart}. */\nexport interface DatePartAggregationOptions {\n  /** The calendar part each row is grouped by. */\n  part: AggregationDatePart;\n  /** The zone the part is read in, an IANA id. Defaults to `UTC`. */\n  timeZone?: string;\n  /**\n   * Whether the server returns every key of the part's domain, the empty\n   * ones filled in. Only when this is the only group.\n   */\n  dense?: boolean;\n}\n\n/** The options of {@link aggregation.first} and {@link aggregation.last}. */\nexport interface EdgeAggregationOptions<\n  FIELDS extends string = string,\n> extends AggregationMetricOptions<FIELDS> {\n  /**\n   * The single-valued, sortable field that orders the records. Defaults to\n   * the model's event time, `analysis.firstLastOrderBy` in the descriptor.\n   */\n  orderBy?: FIELDS;\n}\n\n/** The options of {@link aggregation.percentile}. */\nexport interface PercentileAggregationOptions<\n  FIELDS extends string = string,\n> extends AggregationMetricOptions<FIELDS> {\n  /** Which percentile: finite and within (0, 100). */\n  percentile: number;\n}\n\n/**\n * The sizes Wow's own `AggregationQuery` enforces by throwing.\n *\n * A query that breaks one of them is refused by the server, which says what\n * was wrong but not which metric or group said it. Checking here keeps the\n * complaint next to the call that built the query.\n */\nexport const AGGREGATION_LIMITS = Object.freeze({\n  /** Rows returned when a query names no limit of its own. */\n  DEFAULT_LIMIT: 100,\n  /** The largest `limit`. */\n  MAX_LIMIT: 10_000,\n  /** The most `elements`. */\n  MAX_ELEMENTS: 5,\n  /** The most `groupBy` entries. */\n  MAX_GROUPS: 32,\n  /** The most `metrics`. */\n  MAX_METRICS: 64,\n  /** The most `sort` fields, including those Wow appends for the groups. */\n  MAX_SORT_FIELDS: 32,\n  /** The deepest expression tree. */\n  MAX_EXPRESSION_DEPTH: 8,\n  /** The most expression nodes in the whole query. */\n  MAX_EXPRESSION_NODES: 256,\n});\n"],"mappings":"AAsBA,IAAYA,EAAL,SAAA,EAAA,OAEL,GAAAC,MAAA,QAEA,EAAAC,UAAA,YAEA,EAAAC,eAAA,iBAKA,EAAAC,UAAA,aACF,EAAA,CAAA,CAAA,EAOYC,EAAL,SAAA,EAAA,OAEL,GAAAC,MAAA,QAKA,EAAAC,QAAA,UAEA,EAAAC,IAAA,MAKA,EAAAC,eAAA,iBAKA,EAAAC,WAAA,aAKA,EAAAC,QAAA,UAKA,EAAAC,MAAA,QAKA,EAAAC,KAAA,QACF,EAAA,CAAA,CAAA,EAGYC,EAAL,SAAA,EAAA,OAEL,GAAAC,MAAA,QAEA,EAAAC,SAAA,WAEA,EAAAC,OAAA,SAKA,EAAAC,UAAA,aACF,EAAA,CAAA,CAAA,EAOYC,EAAL,SAAA,EAAA,OACL,GAAAC,OAAA,SACA,EAAAC,OAAA,SACA,EAAAC,KAAA,OACA,EAAAC,IAAA,OACF,EAAA,CAAA,CAAA,EAMYC,EAAL,SAAA,EAAA,OAEL,GAAAC,IAAA,MAEA,EAAAC,SAAA,WAEA,EAAAC,SAAA,WAEA,EAAAC,OAAA,UACF,EAAA,CAAA,CAAA,EAMYC,EAAL,SAAA,EAAA,OACL,GAAAC,KAAA,OACA,EAAAC,QAAA,UACA,EAAAC,MAAA,QACA,EAAAC,KAAA,OACA,EAAAV,IAAA,MACA,EAAAD,KAAA,OACA,EAAAD,OAAA,SACA,EAAAD,OAAA,UACF,EAAA,CAAA,CAAA,EAOYc,EAAL,SAAA,EAAA,OAEL,GAAAC,YAAA,cAKA,EAAAC,aAAA,eAEA,EAAAC,YAAA,cAEA,EAAAC,cAAA,iBACF,EAAA,CAAA,CAAA,EAMYC,EAAL,SAAA,EAAA,OAEL,GAAAC,IAAA,MAEA,EAAAC,IAAA,MAEA,EAAAC,IAAA,MAEA,EAAAC,IAAA,MAEA,EAAAC,OAAA,SAEA,EAAAC,SAAA,YACF,EAAA,CAAA,CAAA,EAqRYC,EAAL,SAAA,EAAA,OAEL,GAAAC,WAAA,aAEA,EAAA/B,SAAA,WAEA,EAAAC,OAAA,UACF,EAAA,CAAA,CAAA,EA6BY+B,EAAL,SAAA,EAAA,OAEL,GAAAC,UAAA,YAEA,EAAAC,QAAA,UAEA,EAAAC,GAAA,KAKA,EAAAC,QAAA,UAEA,EAAAC,IAAA,MAEA,EAAAC,GAAA,MACF,EAAA,CAAA,CAAA,EAGYC,EAAL,SAAA,EAAA,OAEL,GAAAC,GAAA,KAEA,EAAAC,GAAA,KAEA,EAAAC,GAAA,KAEA,EAAAC,IAAA,MAEA,EAAAC,GAAA,KAEA,EAAAC,IAAA,OACF,EAAA,CAAA,CAAA,EAkKaC,EAAqB,OAAO,OAAO,CAE9C,cAAe,IAEf,UAAW,IAEX,aAAc,EAEd,WAAY,GAEZ,YAAa,GAEb,gBAAiB,GAEjB,qBAAsB,EAEtB,qBAAsB,GACxB,CAAC"}