@segmentstream-cloud/ontology 0.16.0 → 0.18.0

package/dist/manifest.d.ts

@@ -12,9 +12,10 @@ import { type SignInOptions, type SignInPolicy } from "./sign-in.js";
  * relationships target warehouse-backed entities and warehouse-backed properties declare `unique`:
  * a relationship with a warehouse-backed end carries `on` and omits `optional` and `onDelete`.
  * Version 6 adds the `countDistinct` measure operator and lets stored entities declare `measures`,
- * whose columns name the stored properties' replication view columns.
+ * whose columns name the stored properties' replication view columns. Version 7 adds the avg, min,
+ * max and filtered measure operators and balanceOver on measures.
  */
-export declare const MANIFEST_VERSION = 6;
+export declare const MANIFEST_VERSION = 7;
 /** The phrase used for a direction the author did not phrase. */
 export declare const DEFAULT_PHRASE = "has";
 export declare const SelectOptionManifest: Schema.Struct<{
@@ -129,6 +130,21 @@ export declare const EntityPermissionsManifest: Schema.Struct<{
     readonly unlink: Schema.optionalKey<Schema.String>;
 }>;
 export type EntityPermissionsManifest = typeof EntityPermissionsManifest.Type;
+/** A measure of an entity: its metadata and the expression the platform computes. */
+export declare const MeasureManifest: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly label: Schema.String;
+    readonly description: Schema.String;
+    readonly unit: Schema.Literals<readonly ["number", "currency", "ratio", "percent"]>;
+    readonly format: Schema.Literals<readonly ["decimal", "currency", "percent"]>;
+    readonly expression: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    /**
+     * The column of the date or timestamp property a balance measure snapshots over; absent for
+     * additive measures and in manifests before version 7. `balance_over` on the wire.
+     */
+    readonly balanceOver: Schema.optionalKey<Schema.String>;
+}>;
+export type MeasureManifest = typeof MeasureManifest.Type;
 export declare const EntityManifest: Schema.Struct<{
     readonly source: Schema.optionalKey<Schema.Struct<{
         readonly asset: Schema.String;
@@ -142,6 +158,11 @@ export declare const EntityManifest: Schema.Struct<{
         readonly unit: Schema.Literals<readonly ["number", "currency", "ratio", "percent"]>;
         readonly format: Schema.Literals<readonly ["decimal", "currency", "percent"]>;
         readonly expression: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        /**
+         * The column of the date or timestamp property a balance measure snapshots over; absent for
+         * additive measures and in manifests before version 7. `balance_over` on the wire.
+         */
+        readonly balanceOver: Schema.optionalKey<Schema.String>;
     }>>>;
     readonly id: Schema.String;
     readonly name: Schema.String;
@@ -270,6 +291,21 @@ export type SignInManifest = typeof SignInManifest.Type;
 /** The JSON contract written since version 4; decoded SDK models remain camelCase. */
 export declare const OntologyManifestWire: Schema.encodeKeys<Schema.Struct<{
     readonly entities: Schema.$Array<Schema.encodeKeys<Schema.Struct<{
+        readonly measures: Schema.optionalKey<Schema.$Array<Schema.encodeKeys<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly label: Schema.String;
+            readonly description: Schema.String;
+            readonly unit: Schema.Literals<readonly ["number", "currency", "ratio", "percent"]>;
+            readonly format: Schema.Literals<readonly ["decimal", "currency", "percent"]>;
+            readonly expression: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            /**
+             * The column of the date or timestamp property a balance measure snapshots over; absent for
+             * additive measures and in manifests before version 7. `balance_over` on the wire.
+             */
+            readonly balanceOver: Schema.optionalKey<Schema.String>;
+        }>, {
+            readonly balanceOver: "balance_over";
+        }>>>;
         readonly properties: Schema.$Array<Schema.encodeKeys<Schema.Struct<{
             readonly column: Schema.optionalKey<Schema.String>;
             readonly scope: Schema.optionalKey<Schema.$Array<Schema.String>>;
@@ -325,14 +361,6 @@ export declare const OntologyManifestWire: Schema.encodeKeys<Schema.Struct<{
             readonly key: Schema.$Array<Schema.String>;
             readonly currency: Schema.optionalKey<Schema.String>;
         }>>;
-        readonly measures: Schema.optionalKey<Schema.$Array<Schema.Struct<{
-            readonly name: Schema.String;
-            readonly label: Schema.String;
-            readonly description: Schema.String;
-            readonly unit: Schema.Literals<readonly ["number", "currency", "ratio", "percent"]>;
-            readonly format: Schema.Literals<readonly ["decimal", "currency", "percent"]>;
-            readonly expression: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-        }>>>;
         readonly id: Schema.String;
         readonly name: Schema.String;
         readonly label: Schema.String;
@@ -413,6 +441,21 @@ export declare const OntologyManifestWire: Schema.encodeKeys<Schema.Struct<{
 /** Historical readers accept either metadata spelling and any manifest version. */
 export declare const OntologyManifest: Schema.Union<readonly [Schema.encodeKeys<Schema.Struct<{
     readonly entities: Schema.$Array<Schema.encodeKeys<Schema.Struct<{
+        readonly measures: Schema.optionalKey<Schema.$Array<Schema.encodeKeys<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly label: Schema.String;
+            readonly description: Schema.String;
+            readonly unit: Schema.Literals<readonly ["number", "currency", "ratio", "percent"]>;
+            readonly format: Schema.Literals<readonly ["decimal", "currency", "percent"]>;
+            readonly expression: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            /**
+             * The column of the date or timestamp property a balance measure snapshots over; absent for
+             * additive measures and in manifests before version 7. `balance_over` on the wire.
+             */
+            readonly balanceOver: Schema.optionalKey<Schema.String>;
+        }>, {
+            readonly balanceOver: "balance_over";
+        }>>>;
         readonly properties: Schema.$Array<Schema.encodeKeys<Schema.Struct<{
             readonly column: Schema.optionalKey<Schema.String>;
             readonly scope: Schema.optionalKey<Schema.$Array<Schema.String>>;
@@ -468,14 +511,6 @@ export declare const OntologyManifest: Schema.Union<readonly [Schema.encodeKeys<
             readonly key: Schema.$Array<Schema.String>;
             readonly currency: Schema.optionalKey<Schema.String>;
         }>>;
-        readonly measures: Schema.optionalKey<Schema.$Array<Schema.Struct<{
-            readonly name: Schema.String;
-            readonly label: Schema.String;
-            readonly description: Schema.String;
-            readonly unit: Schema.Literals<readonly ["number", "currency", "ratio", "percent"]>;
-            readonly format: Schema.Literals<readonly ["decimal", "currency", "percent"]>;
-            readonly expression: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-        }>>>;
         readonly id: Schema.String;
         readonly name: Schema.String;
         readonly label: Schema.String;
@@ -569,6 +604,11 @@ export declare const OntologyManifest: Schema.Union<readonly [Schema.encodeKeys<
             readonly unit: Schema.Literals<readonly ["number", "currency", "ratio", "percent"]>;
             readonly format: Schema.Literals<readonly ["decimal", "currency", "percent"]>;
             readonly expression: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            /**
+             * The column of the date or timestamp property a balance measure snapshots over; absent for
+             * additive measures and in manifests before version 7. `balance_over` on the wire.
+             */
+            readonly balanceOver: Schema.optionalKey<Schema.String>;
         }>>>;
         readonly id: Schema.String;
         readonly name: Schema.String;
@@ -696,31 +736,18 @@ export declare const decodeManifestDocument: (value: unknown) => Effect.Effect<{
         readonly description: string;
         readonly label: string;
         readonly title: string;
-        readonly actions: readonly {
-            readonly name: string;
-            readonly description: string;
-            readonly input: {
-                readonly [x: string]: Schema.Json;
-            };
-            readonly permission?: string | undefined;
-            readonly connections?: readonly string[] | undefined;
-            readonly hints?: {
-                readonly destructive?: boolean | undefined;
-                readonly idempotent?: boolean | undefined;
-            } | undefined;
-        }[];
         readonly properties: readonly {
             readonly optional: boolean;
             readonly name: string;
             readonly label: string;
-            readonly type: "number" | "boolean" | "text" | "email" | "url" | "integer" | "date" | "timestamp" | "select" | "json" | "blob";
+            readonly type: "number" | "boolean" | "date" | "timestamp" | "text" | "email" | "url" | "select" | "integer" | "json" | "blob";
             readonly unique: boolean;
             readonly managed: boolean;
+            readonly min?: number | undefined;
+            readonly max?: number | undefined;
             readonly column?: string | undefined;
             readonly description?: string | undefined;
             readonly maxLength?: number | undefined;
-            readonly min?: number | undefined;
-            readonly max?: number | undefined;
             readonly options?: readonly {
                 readonly value: string;
                 readonly label: string;
@@ -735,23 +762,36 @@ export declare const decodeManifestDocument: (value: unknown) => Effect.Effect<{
         }[];
         readonly relationships: readonly {
             readonly name: string;
+            readonly to: string;
             readonly description: string;
-            readonly phrase: readonly [string, string];
             readonly cardinality: "one" | "many";
-            readonly to: string;
+            readonly phrase: readonly [string, string];
             readonly inverse: string;
             readonly optional?: boolean | undefined;
-            readonly onDelete?: "setNull" | "cascade" | "restrict" | undefined;
             readonly on?: {
                 readonly property: string;
                 readonly targetProperty: string;
             } | undefined;
+            readonly onDelete?: "setNull" | "cascade" | "restrict" | undefined;
             readonly ordered?: boolean | undefined;
         }[];
         readonly indexes: readonly {
             readonly properties: readonly string[];
             readonly unique: boolean;
         }[];
+        readonly actions: readonly {
+            readonly name: string;
+            readonly description: string;
+            readonly input: {
+                readonly [x: string]: Schema.Json;
+            };
+            readonly permission?: string | undefined;
+            readonly connections?: readonly string[] | undefined;
+            readonly hints?: {
+                readonly destructive?: boolean | undefined;
+                readonly idempotent?: boolean | undefined;
+            } | undefined;
+        }[];
         readonly plural: string;
         readonly builtIn: boolean;
         readonly renamedFrom?: string | undefined;
@@ -762,11 +802,12 @@ export declare const decodeManifestDocument: (value: unknown) => Effect.Effect<{
         } | undefined;
         readonly measures?: readonly {
             readonly name: string;
-            readonly label: string;
             readonly description: string;
+            readonly label: string;
             readonly unit: "number" | "currency" | "ratio" | "percent";
-            readonly format: "currency" | "percent" | "decimal";
+            readonly format: "decimal" | "currency" | "percent";
             readonly expression: Schema.Json;
+            readonly balanceOver?: string | undefined;
         }[] | undefined;
         readonly guide?: string | undefined;
         readonly permissions?: {
@@ -800,31 +841,18 @@ export declare const decodeManifestDocument: (value: unknown) => Effect.Effect<{
         readonly description: string;
         readonly label: string;
         readonly title: string;
-        readonly actions: readonly {
-            readonly name: string;
-            readonly description: string;
-            readonly input: {
-                readonly [x: string]: Schema.Json;
-            };
-            readonly permission?: string | undefined;
-            readonly connections?: readonly string[] | undefined;
-            readonly hints?: {
-                readonly destructive?: boolean | undefined;
-                readonly idempotent?: boolean | undefined;
-            } | undefined;
-        }[];
         readonly properties: readonly {
             readonly optional: boolean;
             readonly name: string;
             readonly label: string;
-            readonly type: "number" | "boolean" | "text" | "email" | "url" | "integer" | "date" | "timestamp" | "select" | "json" | "blob";
+            readonly type: "number" | "boolean" | "date" | "timestamp" | "text" | "email" | "url" | "select" | "integer" | "json" | "blob";
             readonly unique: boolean;
             readonly managed: boolean;
+            readonly min?: number | undefined;
+            readonly max?: number | undefined;
             readonly column?: string | undefined;
             readonly description?: string | undefined;
             readonly maxLength?: number | undefined;
-            readonly min?: number | undefined;
-            readonly max?: number | undefined;
             readonly options?: readonly {
                 readonly value: string;
                 readonly label: string;
@@ -839,23 +867,36 @@ export declare const decodeManifestDocument: (value: unknown) => Effect.Effect<{
         }[];
         readonly relationships: readonly {
             readonly name: string;
+            readonly to: string;
             readonly description: string;
-            readonly phrase: readonly [string, string];
             readonly cardinality: "one" | "many";
-            readonly to: string;
+            readonly phrase: readonly [string, string];
             readonly inverse: string;
             readonly optional?: boolean | undefined;
-            readonly onDelete?: "setNull" | "cascade" | "restrict" | undefined;
             readonly on?: {
                 readonly property: string;
                 readonly targetProperty: string;
             } | undefined;
+            readonly onDelete?: "setNull" | "cascade" | "restrict" | undefined;
             readonly ordered?: boolean | undefined;
         }[];
         readonly indexes: readonly {
             readonly properties: readonly string[];
             readonly unique: boolean;
         }[];
+        readonly actions: readonly {
+            readonly name: string;
+            readonly description: string;
+            readonly input: {
+                readonly [x: string]: Schema.Json;
+            };
+            readonly permission?: string | undefined;
+            readonly connections?: readonly string[] | undefined;
+            readonly hints?: {
+                readonly destructive?: boolean | undefined;
+                readonly idempotent?: boolean | undefined;
+            } | undefined;
+        }[];
         readonly plural: string;
         readonly builtIn: boolean;
         readonly renamedFrom?: string | undefined;
@@ -866,11 +907,12 @@ export declare const decodeManifestDocument: (value: unknown) => Effect.Effect<{
         } | undefined;
         readonly measures?: readonly {
             readonly name: string;
-            readonly label: string;
             readonly description: string;
+            readonly label: string;
             readonly unit: "number" | "currency" | "ratio" | "percent";
-            readonly format: "currency" | "percent" | "decimal";
+            readonly format: "decimal" | "currency" | "percent";
             readonly expression: Schema.Json;
+            readonly balanceOver?: string | undefined;
         }[] | undefined;
         readonly guide?: string | undefined;
         readonly permissions?: {
@@ -911,6 +953,13 @@ export declare function canonicalJson(value: unknown): string;
 export declare function formatManifest(manifest: OntologyManifest): string;
 /** The hash of a manifest, computed over its canonical JSON without the `hash` field. */
 export declare function manifestHash(manifest: Readonly<Record<string, unknown>>): string;
+/**
+ * The measures of an entity, of one that passed `check`. A warehouse-backed property's column is its
+ * `column`; a stored property has none, and its column in the replication view is its wire name.
+ * Conditions name columns too, and so does `balanceOver`, which comes from the measure's own
+ * aggregates, top-level or inside arithmetic: `check` lets them name one property at most.
+ */
+export declare function measuresManifest(resolved: ResolvedEntity): ReadonlyArray<MeasureManifest>;
 /** Builds the manifest of a resolved ontology that passed `check`. */
 export declare function buildManifest(input: {
     readonly entities: ReadonlyArray<ResolvedEntity>;

package/dist/manifest.js

@@ -1,4 +1,4 @@
-import { measureExpression } from "./measure.js";
+import { balancesOf, measureExpression } from "./measure.js";
 import { createHash } from "node:crypto";
 import { Effect, Schema, SchemaTransformation } from "effect";
 import { humanize, MEMBER_ROLE } from "./names.js";
@@ -15,9 +15,10 @@ import { DEFAULT_SIGN_IN_POLICY, isSignInPolicy, } from "./sign-in.js";
  * relationships target warehouse-backed entities and warehouse-backed properties declare `unique`:
  * a relationship with a warehouse-backed end carries `on` and omits `optional` and `onDelete`.
  * Version 6 adds the `countDistinct` measure operator and lets stored entities declare `measures`,
- * whose columns name the stored properties' replication view columns.
+ * whose columns name the stored properties' replication view columns. Version 7 adds the avg, min,
+ * max and filtered measure operators and balanceOver on measures.
  */
-export const MANIFEST_VERSION = 6;
+export const MANIFEST_VERSION = 7;
 /** The first version whose documents use snake_case names on the wire. */
 const WIRE_MANIFEST_VERSION = 4;
 /** The phrase used for a direction the author did not phrase. */
@@ -123,20 +124,27 @@ export const EntityPermissionsManifest = Schema.Struct({
     link: Schema.optionalKey(Schema.String),
     unlink: Schema.optionalKey(Schema.String),
 });
+/** A measure of an entity: its metadata and the expression the platform computes. */
+export const MeasureManifest = Schema.Struct({
+    name: Schema.String,
+    label: Schema.String,
+    description: Schema.String,
+    unit: Schema.Literals(["number", "currency", "ratio", "percent"]),
+    format: Schema.Literals(["decimal", "currency", "percent"]),
+    expression: Schema.Json,
+    /**
+     * The column of the date or timestamp property a balance measure snapshots over; absent for
+     * additive measures and in manifests before version 7. `balance_over` on the wire.
+     */
+    balanceOver: Schema.optionalKey(Schema.String),
+});
 export const EntityManifest = Schema.Struct({
     source: Schema.optionalKey(Schema.Struct({
         asset: Schema.String,
         key: Schema.Array(Schema.String),
         currency: Schema.optionalKey(Schema.String),
     })),
-    measures: Schema.optionalKey(Schema.Array(Schema.Struct({
-        name: Schema.String,
-        label: Schema.String,
-        description: Schema.String,
-        unit: Schema.Literals(["number", "currency", "ratio", "percent"]),
-        format: Schema.Literals(["decimal", "currency", "percent"]),
-        expression: Schema.Json,
-    }))),
+    measures: Schema.optionalKey(Schema.Array(MeasureManifest)),
     id: Schema.String,
     name: Schema.String,
     label: Schema.String,
@@ -206,8 +214,10 @@ const RelationshipManifestWire = Schema.Struct({
     on: Schema.optionalKey(Schema.Struct({ property: Schema.String, targetProperty: Schema.String }).pipe(Schema.encodeKeys({ targetProperty: "target_property" }))),
     onDelete: Schema.optionalKey(OnDeleteWire),
 }).pipe(Schema.encodeKeys({ onDelete: "on_delete" }));
+const MeasureManifestWire = MeasureManifest.pipe(Schema.encodeKeys({ balanceOver: "balance_over" }));
 const EntityManifestWire = Schema.Struct({
     ...EntityManifest.fields,
+    measures: Schema.optionalKey(Schema.Array(MeasureManifestWire)),
     properties: Schema.Array(PropertyManifestWire),
     relationships: Schema.Array(RelationshipManifestWire),
 }).pipe(Schema.encodeKeys({ builtIn: "built_in", renamedFrom: "renamed_from" }));
@@ -348,27 +358,33 @@ function relationshipManifest(input) {
     };
 }
 /**
- * The measures of an entity. A warehouse-backed property's column is its `column`; a stored property
- * has none, and its column in the replication view is its wire name.
+ * The measures of an entity, of one that passed `check`. A warehouse-backed property's column is its
+ * `column`; a stored property has none, and its column in the replication view is its wire name.
+ * Conditions name columns too, and so does `balanceOver`, which comes from the measure's own
+ * aggregates, top-level or inside arithmetic: `check` lets them name one property at most.
  */
-function measuresManifest(resolved) {
+export function measuresManifest(resolved) {
     const columns = new Map(resolved.properties.map((property) => [
         property.name,
         property.definition.column ?? property.name,
     ]));
-    return Object.entries(resolved.entity.definition.measures ?? {}).map(([name, measure]) => ({
-        name,
-        label: measure.label ?? humanize(name),
-        description: measure.description ?? "",
-        unit: measure.unit ?? "number",
-        format: measure.format ??
-            (measure.unit === "currency"
-                ? "currency"
-                : measure.unit === "percent"
-                    ? "percent"
-                    : "decimal"),
-        expression: measureExpression(measure, columns),
-    }));
+    return Object.entries(resolved.entity.definition.measures ?? {}).map(([name, measure]) => {
+        const [balance] = balancesOf(measure);
+        return {
+            name,
+            label: measure.label ?? humanize(name),
+            description: measure.description ?? "",
+            unit: measure.unit ?? "number",
+            format: measure.format ??
+                (measure.unit === "currency"
+                    ? "currency"
+                    : measure.unit === "percent"
+                        ? "percent"
+                        : "decimal"),
+            expression: measureExpression(measure, columns),
+            ...(balance === undefined ? {} : { balanceOver: columns.get(balance) ?? balance }),
+        };
+    });
 }
 /** `warehouseBacked` names the ontology's warehouse-backed entities, which relationships may target. */
 function entityManifest(input) {

package/dist/measure.d.ts

@@ -1,3 +1,26 @@
+import type { AggregateValue, MeasureConditionOperator } from "./aggregate-filters.js";
+/**
+ * A condition on the rows an aggregate reads: a property of the measure's own entity, in TypeScript
+ * names, and an operator with literal values, as a request filter takes them.
+ */
+export interface MeasureCondition {
+    readonly property: string;
+    readonly operator: MeasureConditionOperator;
+    readonly value?: AggregateValue;
+    readonly values?: ReadonlyArray<AggregateValue>;
+}
+/**
+ * A condition as a `filtered` expression holds it: like a `column` expression, it names a property
+ * until `measureExpression` maps it to the property's column for the manifest.
+ */
+export interface MeasureColumnCondition {
+    readonly column: string;
+    readonly operator: MeasureConditionOperator;
+    readonly value?: AggregateValue;
+    readonly values?: ReadonlyArray<AggregateValue>;
+}
+/** The aggregates a measure expression may contain, `count` included. */
+export declare const MEASURE_AGGREGATES: readonly ["count", "sum", "countDistinct", "avg", "min", "max"];
 export type MeasureExpression = {
     readonly op: "count";
 } | {
@@ -7,8 +30,17 @@ export type MeasureExpression = {
     readonly op: "literal";
     readonly value: string;
 } | {
-    readonly op: "sum" | "countDistinct" | "add" | "subtract" | "multiply" | "divide";
+    readonly op: "sum" | "countDistinct" | "avg" | "min" | "max" | "add" | "subtract" | "multiply" | "divide";
+    readonly args: ReadonlyArray<MeasureExpression>;
+}
+/**
+ * One aggregate over the rows that meet every condition. The condition wraps the aggregate, so a
+ * platform that does not know `filtered` cannot compute the aggregate unfiltered.
+ */
+ | {
+    readonly op: "filtered";
     readonly args: ReadonlyArray<MeasureExpression>;
+    readonly where: ReadonlyArray<MeasureColumnCondition>;
 };
 export interface MeasureOptions {
     readonly description: string;
@@ -16,17 +48,51 @@ export interface MeasureOptions {
     readonly unit?: "number" | "currency" | "ratio" | "percent";
     readonly format?: "decimal" | "currency" | "percent";
 }
-export type Measure = MeasureExpression & Partial<MeasureOptions>;
+/** What an aggregate declares about the rows it reads, beside a measure's options. */
+export interface AggregateDeclarations {
+    /** 1–10 conditions on properties of the entity, all of which the rows read must meet. */
+    readonly where?: ReadonlyArray<MeasureCondition>;
+    /**
+     * The date or timestamp property the entity's rows are snapshots over, such as a daily stock
+     * table's date. Summing snapshots over days would overstate the balance, so a request must group
+     * by the property or filter it to one day. Arithmetic and references over the aggregate inherit
+     * it.
+     */
+    readonly balanceOver?: string;
+}
+/**
+ * The options of `count`, `sum`, `countDistinct`, `avg`, `min` and `max`: a measure's options with
+ * the aggregate's declarations, or the declarations alone for an aggregate that is an argument of
+ * arithmetic.
+ */
+export type AggregateOptions = (MeasureOptions & AggregateDeclarations) | AggregateDeclarations;
+export type Measure = MeasureExpression & Partial<MeasureOptions> & {
+    /** An aggregate's conditions, as its builder's `where` option declares them. */
+    readonly where?: ReadonlyArray<MeasureCondition | MeasureColumnCondition>;
+    /** An aggregate's balance property, as its builder's `balanceOver` option declares it. */
+    readonly balanceOver?: string;
+};
 export type Measures = Readonly<Record<string, Measure>>;
-/** Arithmetic combines aggregates; references name another measure of the same entity. */
+/**
+ * Arithmetic combines aggregates; references name another measure of the same entity. Every
+ * aggregate takes `where`, conditions on properties of the entity that the rows it reads must meet,
+ * and `balanceOver`, the date its rows are snapshots over.
+ */
 export declare const m: {
-    readonly count: (options?: MeasureOptions) => Measure;
-    readonly sum: (property: string, options?: MeasureOptions) => Measure;
+    readonly count: (options?: AggregateOptions) => Measure;
+    /** The sum of an integer or number property. */
+    readonly sum: (property: string, options?: AggregateOptions) => Measure;
     /**
      * The number of distinct non-null values of a text, email, url, select, integer, date or timestamp
      * property. Distinct counts do not add up across groups.
      */
-    readonly countDistinct: (property: string, options?: MeasureOptions) => Measure;
+    readonly countDistinct: (property: string, options?: AggregateOptions) => Measure;
+    /** The average of an integer or number property, ignoring nulls. Averages do not add up. */
+    readonly avg: (property: string, options?: AggregateOptions) => Measure;
+    /** The least value of an integer or number property. Minimums do not add up. */
+    readonly min: (property: string, options?: AggregateOptions) => Measure;
+    /** The greatest value of an integer or number property. Maximums do not add up. */
+    readonly max: (property: string, options?: AggregateOptions) => Measure;
     readonly ref: (name: string, options?: MeasureOptions) => Measure;
     readonly literal: (value: number | string, options?: MeasureOptions) => Measure;
     readonly add: (left: MeasureExpression, right: MeasureExpression, options?: MeasureOptions) => Measure;
@@ -34,9 +100,22 @@ export declare const m: {
     readonly multiply: (left: MeasureExpression, right: MeasureExpression, options?: MeasureOptions) => Measure;
     readonly divide: (left: MeasureExpression, right: MeasureExpression, options?: MeasureOptions) => Measure;
 };
+/** The conditions an expression declares: an aggregate's `where` option, or a `filtered` node's. */
+export declare function conditionsOf(value: Measure | MeasureExpression): ReadonlyArray<MeasureCondition | MeasureColumnCondition> | undefined;
+/** The balance property an expression node declares: an aggregate's `balanceOver` option. */
+export declare function balanceOf(value: Measure | MeasureExpression): unknown;
+/**
+ * The balance properties a measure's own aggregates declare, top-level or inside arithmetic and
+ * `filtered` expressions, without duplicates. References are not followed: the platform inherits a
+ * referenced measure's balance itself.
+ */
+export declare function balancesOf(value: Measure | MeasureExpression): ReadonlyArray<string>;
+/** The property a condition names: `property` as authored, `column` in a `filtered` expression. */
+export declare function conditionProperty(condition: object): unknown;
 /**
  * Strip authoring options and resolve logical properties to physical columns for the manifest: a
  * warehouse-backed property's `column`, or a stored property's replication view column, which is its
- * wire name.
+ * wire name. An aggregate's `where` becomes the `filtered` expression that wraps it, its conditions
+ * naming columns too.
  */
 export declare function measureExpression(value: MeasureExpression, columns: ReadonlyMap<string, string>): MeasureExpression;