@visactor/vbi 0.4.17 → 0.4.20

package/dist/pipeline/vqueryDSL/aggregateMap.d.ts

@@ -0,0 +1,50 @@
+export type VQueryBaseAggregateFunc = 'count' | 'count_distinct' | 'sum' | 'avg' | 'min' | 'max' | 'variance' | 'variance_pop' | 'stddev' | 'median' | 'quantile';
+export type VQueryDateAggregateFunc = 'to_year' | 'to_quarter' | 'to_month' | 'to_week' | 'to_day' | 'to_hour' | 'to_minute' | 'to_second';
+export type VQueryAggregateFunc = VQueryBaseAggregateFunc | VQueryDateAggregateFunc;
+export type VQueryAggregate = {
+    func: VQueryAggregateFunc;
+    quantile?: number;
+};
+export type VBIMeasureAggregateInput = {
+    func: 'count';
+} | {
+    func: 'countDistinct';
+} | {
+    func: 'sum';
+} | {
+    func: 'avg';
+} | {
+    func: 'min';
+} | {
+    func: 'max';
+} | {
+    func: 'variance';
+} | {
+    func: 'variancePop';
+} | {
+    func: 'stddev';
+} | {
+    func: 'median';
+} | {
+    func: 'quantile';
+    quantile?: number;
+};
+export type VBIDimensionAggregateInput = {
+    func: 'toYear';
+} | {
+    func: 'toQuarter';
+} | {
+    func: 'toMonth';
+} | {
+    func: 'toWeek';
+} | {
+    func: 'toDay';
+} | {
+    func: 'toHour';
+} | {
+    func: 'toMinute';
+} | {
+    func: 'toSecond';
+};
+export declare const mapAggregateForVQuery: (aggregate: VBIMeasureAggregateInput | undefined) => VQueryAggregate | undefined;
+export declare const mapDimensionAggregateForVQuery: (aggregate: VBIDimensionAggregateInput | undefined) => VQueryAggregate | undefined;

package/dist/pipeline/vqueryDSL/buildOrderBy.d.ts

@@ -0,0 +1,2 @@
+import type { buildPipe } from './types';
+export declare const buildOrderBy: buildPipe;

package/dist/pipeline/vqueryDSL/index.d.ts

@@ -1,4 +1,3 @@
 import type { VQueryDSL } from '@visactor/vquery';
-import type { VBIDSL } from '../../types';
-import type { VBIBuilder } from '../../builder';
-export declare const buildVQuery: (vbiDSL: VBIDSL, builder: VBIBuilder) => VQueryDSL;
+import type { VBIChartBuilderInterface, VBIChartDSL } from '../../types';
+export declare const buildVQuery: (vbiDSL: VBIChartDSL, builder: VBIChartBuilderInterface<any, any>) => VQueryDSL;

package/dist/pipeline/vqueryDSL/resolveDatePredicate.d.ts

@@ -0,0 +1,7 @@
+import type { VBIWhereDateBounds, VBIWhereDatePredicate } from '../../types';
+export type DateRange = {
+    start: string;
+    end: string;
+    bounds: VBIWhereDateBounds;
+};
+export declare function resolveDatePredicate(predicate: VBIWhereDatePredicate, now?: Date): DateRange;

package/dist/pipeline/vqueryDSL/types.d.ts

@@ -1,7 +1,7 @@
 import type { VQueryDSL } from '@visactor/vquery';
-import type { VBIDSL } from '../../types';
-import type { VBIBuilder } from '../../builder';
-export type buildPipe = (queryDSL: VQueryDSL, context: {
-    vbiDSL: VBIDSL;
-    builder: VBIBuilder;
-}) => VQueryDSL;
+import type { VBIChartBuilderInterface, VBIChartDSL } from '../../types';
+export type buildPipeContext = {
+    vbiDSL: VBIChartDSL;
+    builder: VBIChartBuilderInterface<any, any>;
+};
+export type buildPipe = (queryDSL: VQueryDSL, context: buildPipeContext) => VQueryDSL;

package/dist/types/builder/VBIInterface.d.ts

@@ -1,9 +1,9 @@
-import type { VQueryDSL } from '@visactor/vquery';
-import type { VBIDSL } from '../dsl';
-import type { VSeedDSL } from '@visactor/vseed';
+import type { DefaultVBIQueryDSL, DefaultVBISeedDSL } from '../../builder/adapters/vquery-vseed/types';
+import type { VBIChartDSL } from '../dsl';
+import type { BuildVSeedOptions } from './build-vseed';
 import type { MeasuresBuilder, DimensionsBuilder, ChartTypeBuilder, HavingFilterBuilder, WhereFilterBuilder, ThemeBuilder, LocaleBuilder, LimitBuilder, UndoManager } from '../../builder/features';
 import type { Map, Doc } from 'yjs';
-export interface VBIBuilderInterface {
+export interface VBIChartBuilderInterface<TQueryDSL = DefaultVBIQueryDSL, TSeedDSL = DefaultVBISeedDSL> {
     doc: Doc;
     dsl: Map<any>;
     undoManager: UndoManager;
@@ -17,8 +17,8 @@ export interface VBIBuilderInterface {
     limit: LimitBuilder;
     applyUpdate: (update: Uint8Array, origin?: any) => void;
     encodeStateAsUpdate: (targetStateVector?: Uint8Array) => Uint8Array;
-    buildVSeed: () => Promise<VSeedDSL>;
-    buildVQuery: () => VQueryDSL;
-    build: () => VBIDSL;
+    buildVSeed: (options?: BuildVSeedOptions) => Promise<TSeedDSL>;
+    buildVQuery: () => TQueryDSL;
+    build: () => VBIChartDSL;
     isEmpty: () => boolean;
 }

package/dist/types/builder/adapter.d.ts

@@ -0,0 +1,23 @@
+import type { DefaultVBIQueryDSL, DefaultVBISeedDSL } from '../../builder/adapters/vquery-vseed/types';
+import type { Map } from 'yjs';
+import type { VBIChartDSL } from '../dsl';
+import type { BuildVSeedOptions } from './build-vseed';
+import type { VBIChartBuilderInterface } from './VBIInterface';
+export interface VBIChartBuildVQueryContext<TQueryDSL = DefaultVBIQueryDSL, TSeedDSL = DefaultVBISeedDSL> {
+    dsl: Map<any>;
+    vbiDSL: VBIChartDSL;
+    builder: VBIChartBuilderInterface<TQueryDSL, TSeedDSL>;
+}
+export interface VBIChartBuildVSeedContext<TQueryDSL = DefaultVBIQueryDSL, TSeedDSL = DefaultVBISeedDSL> extends VBIChartBuildVQueryContext<TQueryDSL, TSeedDSL> {
+    options: BuildVSeedOptions;
+    queryDSL: TQueryDSL;
+}
+export type VBIChartQueryBuilder<TQueryDSL = DefaultVBIQueryDSL, TSeedDSL = DefaultVBISeedDSL> = (context: VBIChartBuildVQueryContext<TQueryDSL, TSeedDSL>) => TQueryDSL;
+export type VBIChartSeedBuilder<TQueryDSL = DefaultVBIQueryDSL, TSeedDSL = DefaultVBISeedDSL> = (context: VBIChartBuildVSeedContext<TQueryDSL, TSeedDSL>) => Promise<TSeedDSL> | TSeedDSL;
+export interface VBIChartBuilderAdapters<TQueryDSL = DefaultVBIQueryDSL, TSeedDSL = DefaultVBISeedDSL> {
+    buildVQuery: VBIChartQueryBuilder<TQueryDSL, TSeedDSL>;
+    buildVSeed: VBIChartSeedBuilder<TQueryDSL, TSeedDSL>;
+}
+export interface VBIChartBuilderOptions<TQueryDSL = DefaultVBIQueryDSL, TSeedDSL = DefaultVBISeedDSL> {
+    adapters?: Partial<VBIChartBuilderAdapters<TQueryDSL, TSeedDSL>>;
+}

package/dist/types/builder/build-vseed.d.ts

@@ -0,0 +1,3 @@
+export interface BuildVSeedOptions {
+    signal?: AbortSignal;
+}

package/dist/types/builder/context.d.ts

@@ -1,4 +1,4 @@
-import { VBIDSL } from '../dsl';
+import { VBIChartDSL } from '../dsl';
 export interface BuilderContext {
-    getVBIDSL(): VBIDSL;
+    getVBIChartDSL(): VBIChartDSL;
 }

package/dist/types/builder/index.d.ts

@@ -1,2 +1,4 @@
-export type { VBIBuilderInterface } from './VBIInterface';
-export type { ObserveCallback } from './observe';
+export type { BuildVSeedOptions } from './build-vseed';
+export type { VBIChartBuilderInterface } from './VBIInterface';
+export type { VBIChartBuildVQueryContext, VBIChartBuildVSeedContext, VBIChartQueryBuilder, VBIChartSeedBuilder, VBIChartBuilderAdapters, VBIChartBuilderOptions, } from './adapter';
+export type { ObserveCallback, ObserveDeepCallback } from './observe';

package/dist/types/builder/observe.d.ts

@@ -1,2 +1,3 @@
-import { YMapEvent, Transaction } from 'yjs';
+import type { YEvent, YMapEvent, Transaction } from 'yjs';
 export type ObserveCallback = (e: YMapEvent<any>, trans: Transaction) => void;
+export type ObserveDeepCallback = (events: YEvent<any>[], trans: Transaction) => void;

package/dist/types/connector/query.d.ts

@@ -11,5 +11,6 @@ export declare const zVBIQueryProps: z.ZodObject<{
         type: z.ZodString;
     }, z.core.$strip>>;
     connectorId: z.ZodString;
+    signal: z.ZodOptional<z.ZodCustom<AbortSignal, AbortSignal>>;
 }, z.core.$strip>;
 export type VBIQueryProps = z.infer<typeof zVBIQueryProps>;

package/dist/types/dsl/dimensions/aggregate.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+export declare const VBI_DIMENSION_DATE_AGGREGATE_FUNCS: readonly ["toYear", "toQuarter", "toMonth", "toWeek", "toDay", "toHour", "toMinute", "toSecond"];
+export declare const zDimensionAggregate: z.ZodObject<{
+    func: z.ZodEnum<{
+        toYear: "toYear";
+        toQuarter: "toQuarter";
+        toMonth: "toMonth";
+        toWeek: "toWeek";
+        toDay: "toDay";
+        toHour: "toHour";
+        toMinute: "toMinute";
+        toSecond: "toSecond";
+    }>;
+}, z.core.$strip>;
+export type VBIDimensionAggregate = z.infer<typeof zDimensionAggregate>;

package/dist/types/dsl/dimensions/dimensions.d.ts

@@ -3,12 +3,74 @@ export declare const zVBIDimensionSchema: z.ZodObject<{
     id: z.ZodString;
     field: z.ZodString;
     alias: z.ZodString;
+    encoding: z.ZodOptional<z.ZodEnum<{
+        column: "column";
+        xAxis: "xAxis";
+        yAxis: "yAxis";
+        angle: "angle";
+        color: "color";
+        detail: "detail";
+        tooltip: "tooltip";
+        label: "label";
+        row: "row";
+        player: "player";
+        hierarchy: "hierarchy";
+    }>>;
+    aggregate: z.ZodOptional<z.ZodObject<{
+        func: z.ZodEnum<{
+            toYear: "toYear";
+            toQuarter: "toQuarter";
+            toMonth: "toMonth";
+            toWeek: "toWeek";
+            toDay: "toDay";
+            toHour: "toHour";
+            toMinute: "toMinute";
+            toSecond: "toSecond";
+        }>;
+    }, z.core.$strip>>;
+    sort: z.ZodOptional<z.ZodObject<{
+        order: z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const zVBIDimensionGroupSchema: z.ZodType<VBIDimensionGroup>;
 export declare const zVBIDimensionTree: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
     id: z.ZodString;
     field: z.ZodString;
     alias: z.ZodString;
+    encoding: z.ZodOptional<z.ZodEnum<{
+        column: "column";
+        xAxis: "xAxis";
+        yAxis: "yAxis";
+        angle: "angle";
+        color: "color";
+        detail: "detail";
+        tooltip: "tooltip";
+        label: "label";
+        row: "row";
+        player: "player";
+        hierarchy: "hierarchy";
+    }>>;
+    aggregate: z.ZodOptional<z.ZodObject<{
+        func: z.ZodEnum<{
+            toYear: "toYear";
+            toQuarter: "toQuarter";
+            toMonth: "toMonth";
+            toWeek: "toWeek";
+            toDay: "toDay";
+            toHour: "toHour";
+            toMinute: "toMinute";
+            toSecond: "toSecond";
+        }>;
+    }, z.core.$strip>>;
+    sort: z.ZodOptional<z.ZodObject<{
+        order: z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>;
+    }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodType<VBIDimensionGroup, unknown, z.core.$ZodTypeInternals<VBIDimensionGroup, unknown>>]>>;
 export type VBIDimension = z.infer<typeof zVBIDimensionSchema>;
 export type VBIDimensionGroup = {

package/dist/types/dsl/encoding.d.ts

@@ -1,11 +1,11 @@
 import { z } from 'zod';
 export declare const VBI_SUPPORTED_ENCODINGS: readonly ["yAxis", "xAxis", "color", "label", "tooltip", "size"];
 export declare const zVBIEncoding: z.ZodEnum<{
-    yAxis: "yAxis";
     xAxis: "xAxis";
+    yAxis: "yAxis";
     color: "color";
-    label: "label";
     tooltip: "tooltip";
+    label: "label";
     size: "size";
 }>;
 export type VBIEncoding = z.infer<typeof zVBIEncoding>;

package/dist/types/dsl/havingFilter/having.d.ts

@@ -1,12 +1,31 @@
 import { z } from 'zod';
+import { zAggregate } from '../measures/aggregate';
 declare const zHavingLogicalOperator: z.ZodEnum<{
     and: "and";
     or: "or";
 }>;
+export type VBIHavingAggregate = z.infer<typeof zAggregate>;
 export declare const zVBIHavingFilter: z.ZodObject<{
     id: z.ZodString;
     field: z.ZodString;
-    op: z.ZodOptional<z.ZodString>;
+    aggregate: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        func: z.ZodEnum<{
+            count: "count";
+            countDistinct: "countDistinct";
+            sum: "sum";
+            avg: "avg";
+            min: "min";
+            max: "max";
+            variance: "variance";
+            variancePop: "variancePop";
+            stddev: "stddev";
+            median: "median";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        func: z.ZodLiteral<"quantile">;
+        quantile: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>], "func">;
+    op: z.ZodString;
     value: z.ZodOptional<z.ZodAny>;
 }, z.core.$strip>;
 export type VBIHavingFilter = z.infer<typeof zVBIHavingFilter>;

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

@@ -1,7 +1,9 @@
+export type { VBISort, VBISortOrder } from './sort';
 export type { VBIDimensionTree, VBIDimensionGroup, VBIDimension } from './dimensions/dimensions';
-export type { VBIMeasureTree, VBIMeasureGroup, VBIMeasure } from './measures/measures';
-export type { VBIFilter, VBIWhereGroup, VBIWhereClause } from './whereFilter/filters';
-export type { VBIHavingFilter, VBIHavingGroup, VBIHavingClause } from './havingFilter/having';
+export type { VBIDimensionAggregate } from './dimensions/aggregate';
+export type { VBIMeasureTree, VBIMeasureGroup, VBIMeasure, VBIMeasureFormat } from './measures/measures';
+export type { VBIWhereDateInput, VBIWhereDateUnit, VBIWhereDateBounds, VBIWhereDatePeriod, VBIWhereDatePredicate, VBIWhereFilter, VBIWhereScalarFilter, VBIWhereDateFilter, VBIWhereGroup, VBIWhereClause, } from './whereFilter/filters';
+export type { VBIHavingFilter, VBIHavingGroup, VBIHavingClause, VBIHavingAggregate } from './havingFilter/having';
 export type { VBIDSLTheme } from './theme/theme';
 export type { VBIDSLLocale } from './locale/locale';
-export type { VBIDSL, VBIDSLInput } from './vbi/vbi';
+export type { VBIChartDSL, VBIChartDSLInput } from './vbi/vbi';

package/dist/types/dsl/measures/aggregate.d.ts

@@ -1,7 +1,19 @@
 import { z } from 'zod';
+export declare const VBI_MEASURE_SIMPLE_AGGREGATE_FUNCS: readonly ["count", "countDistinct", "sum", "avg", "min", "max", "variance", "variancePop", "stddev", "median"];
 export declare const zAggregate: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    func: z.ZodLiteral<"sum" | "count" | "avg" | "min" | "max">;
+    func: z.ZodEnum<{
+        count: "count";
+        countDistinct: "countDistinct";
+        sum: "sum";
+        avg: "avg";
+        min: "min";
+        max: "max";
+        variance: "variance";
+        variancePop: "variancePop";
+        stddev: "stddev";
+        median: "median";
+    }>;
 }, z.core.$strip>, z.ZodObject<{
     func: z.ZodLiteral<"quantile">;
-    quantile: z.ZodNumber;
+    quantile: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>], "func">;

package/dist/types/dsl/measures/measures.d.ts

@@ -1,22 +1,126 @@
 import { z } from 'zod';
+import type { NumFormat } from '@visactor/vseed';
+export declare const zVBIMeasureFormat: z.ZodUnion<readonly [z.ZodObject<{
+    autoFormat: z.ZodLiteral<true>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+        number: "number";
+        percent: "percent";
+        permille: "permille";
+        scientific: "scientific";
+    }>>>;
+    ratio: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    symbol: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+    thousandSeparator: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    prefix: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+    suffix: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+    fractionDigits: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    significantDigits: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    roundingPriority: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+        morePrecision: "morePrecision";
+        lessPrecision: "lessPrecision";
+    }>>>;
+    roundingMode: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+        floor: "floor";
+        ceil: "ceil";
+        expand: "expand";
+        trunc: "trunc";
+        halfCeil: "halfCeil";
+        halfFloor: "halfFloor";
+        halfExpand: "halfExpand";
+        halfTrunc: "halfTrunc";
+        halfEven: "halfEven";
+    }>>>;
+    autoFormat: z.ZodOptional<z.ZodLiteral<false>>;
+}, z.core.$strip>]>;
+export type VBIMeasureFormat = {
+    autoFormat: true;
+} | ({
+    autoFormat?: false;
+} & NumFormat);
 export declare const zVBIMeasure: z.ZodObject<{
     id: z.ZodString;
     field: z.ZodString;
     alias: z.ZodString;
     encoding: z.ZodEnum<{
-        yAxis: "yAxis";
+        value: "value";
+        column: "column";
         xAxis: "xAxis";
+        yAxis: "yAxis";
+        angle: "angle";
         color: "color";
-        label: "label";
+        detail: "detail";
         tooltip: "tooltip";
+        label: "label";
+        min: "min";
+        max: "max";
+        median: "median";
+        primaryYAxis: "primaryYAxis";
+        secondaryYAxis: "secondaryYAxis";
+        radius: "radius";
         size: "size";
+        q1: "q1";
+        q3: "q3";
+        outliers: "outliers";
+        x0: "x0";
+        x1: "x1";
     }>;
     aggregate: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        func: z.ZodLiteral<"sum" | "count" | "avg" | "min" | "max">;
+        func: z.ZodEnum<{
+            count: "count";
+            countDistinct: "countDistinct";
+            sum: "sum";
+            avg: "avg";
+            min: "min";
+            max: "max";
+            variance: "variance";
+            variancePop: "variancePop";
+            stddev: "stddev";
+            median: "median";
+        }>;
     }, z.core.$strip>, z.ZodObject<{
         func: z.ZodLiteral<"quantile">;
-        quantile: z.ZodNumber;
+        quantile: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>], "func">;
+    format: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        autoFormat: z.ZodLiteral<true>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+            number: "number";
+            percent: "percent";
+            permille: "permille";
+            scientific: "scientific";
+        }>>>;
+        ratio: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        symbol: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+        thousandSeparator: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        prefix: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+        suffix: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+        fractionDigits: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        significantDigits: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        roundingPriority: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+            morePrecision: "morePrecision";
+            lessPrecision: "lessPrecision";
+        }>>>;
+        roundingMode: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+            floor: "floor";
+            ceil: "ceil";
+            expand: "expand";
+            trunc: "trunc";
+            halfCeil: "halfCeil";
+            halfFloor: "halfFloor";
+            halfExpand: "halfExpand";
+            halfTrunc: "halfTrunc";
+            halfEven: "halfEven";
+        }>>>;
+        autoFormat: z.ZodOptional<z.ZodLiteral<false>>;
+    }, z.core.$strip>]>>;
+    sort: z.ZodOptional<z.ZodObject<{
+        order: z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const zVBIMeasureGroup: z.ZodType<VBIMeasureGroup>;
 export declare const zVBIMeasureTree: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
@@ -24,19 +128,84 @@ export declare const zVBIMeasureTree: z.ZodArray<z.ZodUnion<readonly [z.ZodObjec
     field: z.ZodString;
     alias: z.ZodString;
     encoding: z.ZodEnum<{
-        yAxis: "yAxis";
+        value: "value";
+        column: "column";
         xAxis: "xAxis";
+        yAxis: "yAxis";
+        angle: "angle";
         color: "color";
-        label: "label";
+        detail: "detail";
         tooltip: "tooltip";
+        label: "label";
+        min: "min";
+        max: "max";
+        median: "median";
+        primaryYAxis: "primaryYAxis";
+        secondaryYAxis: "secondaryYAxis";
+        radius: "radius";
         size: "size";
+        q1: "q1";
+        q3: "q3";
+        outliers: "outliers";
+        x0: "x0";
+        x1: "x1";
     }>;
     aggregate: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        func: z.ZodLiteral<"sum" | "count" | "avg" | "min" | "max">;
+        func: z.ZodEnum<{
+            count: "count";
+            countDistinct: "countDistinct";
+            sum: "sum";
+            avg: "avg";
+            min: "min";
+            max: "max";
+            variance: "variance";
+            variancePop: "variancePop";
+            stddev: "stddev";
+            median: "median";
+        }>;
     }, z.core.$strip>, z.ZodObject<{
         func: z.ZodLiteral<"quantile">;
-        quantile: z.ZodNumber;
+        quantile: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>], "func">;
+    format: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        autoFormat: z.ZodLiteral<true>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+            number: "number";
+            percent: "percent";
+            permille: "permille";
+            scientific: "scientific";
+        }>>>;
+        ratio: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        symbol: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+        thousandSeparator: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        prefix: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+        suffix: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+        fractionDigits: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        significantDigits: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        roundingPriority: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+            morePrecision: "morePrecision";
+            lessPrecision: "lessPrecision";
+        }>>>;
+        roundingMode: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+            floor: "floor";
+            ceil: "ceil";
+            expand: "expand";
+            trunc: "trunc";
+            halfCeil: "halfCeil";
+            halfFloor: "halfFloor";
+            halfExpand: "halfExpand";
+            halfTrunc: "halfTrunc";
+            halfEven: "halfEven";
+        }>>>;
+        autoFormat: z.ZodOptional<z.ZodLiteral<false>>;
+    }, z.core.$strip>]>>;
+    sort: z.ZodOptional<z.ZodObject<{
+        order: z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>;
+    }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodType<VBIMeasureGroup, unknown, z.core.$ZodTypeInternals<VBIMeasureGroup, unknown>>]>>;
 export type VBIMeasure = z.infer<typeof zVBIMeasure>;
 export type VBIMeasureGroup = {

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

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+export declare const zVBISortOrder: z.ZodEnum<{
+    asc: "asc";
+    desc: "desc";
+}>;
+export declare const zVBISort: z.ZodObject<{
+    order: z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>;
+}, z.core.$strip>;
+export type VBISortOrder = z.infer<typeof zVBISortOrder>;
+export type VBISort = z.infer<typeof zVBISort>;