@visactor/vbi 0.4.19 → 0.4.21

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

@@ -1,9 +1,11 @@
-export type VQueryAggregateFunc = 'count' | 'count_distinct' | 'sum' | 'avg' | 'min' | 'max' | 'variance' | 'variance_pop' | 'stddev' | 'median' | 'quantile';
+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 VBIAggregateInput = {
+export type VBIMeasureAggregateInput = {
     func: 'count';
 } | {
     func: 'countDistinct';
@@ -27,4 +29,22 @@ export type VBIAggregateInput = {
     func: 'quantile';
     quantile?: number;
 };
-export declare const mapAggregateForVQuery: (aggregate: VBIAggregateInput | undefined) => VQueryAggregate | undefined;
+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,3 +1,3 @@
 import type { VQueryDSL } from '@visactor/vquery';
-import type { VBIBuilderInterface, VBIDSL } from '../../types';
-export declare const buildVQuery: (vbiDSL: VBIDSL, builder: VBIBuilderInterface<any, any>) => 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,6 +1,7 @@
 import type { VQueryDSL } from '@visactor/vquery';
-import type { VBIBuilderInterface, VBIDSL } from '../../types';
-export type buildPipe = (queryDSL: VQueryDSL, context: {
-    vbiDSL: VBIDSL;
-    builder: VBIBuilderInterface<any, any>;
-}) => 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,8 +1,9 @@
 import type { DefaultVBIQueryDSL, DefaultVBISeedDSL } from '../../builder/adapters/vquery-vseed/types';
-import type { VBIDSL } from '../dsl';
+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<TQueryDSL = DefaultVBIQueryDSL, TSeedDSL = DefaultVBISeedDSL> {
+export interface VBIChartBuilderInterface<TQueryDSL = DefaultVBIQueryDSL, TSeedDSL = DefaultVBISeedDSL> {
     doc: Doc;
     dsl: Map<any>;
     undoManager: UndoManager;
@@ -16,8 +17,8 @@ export interface VBIBuilderInterface<TQueryDSL = DefaultVBIQueryDSL, TSeedDSL =
     limit: LimitBuilder;
     applyUpdate: (update: Uint8Array, origin?: any) => void;
     encodeStateAsUpdate: (targetStateVector?: Uint8Array) => Uint8Array;
-    buildVSeed: () => Promise<TSeedDSL>;
+    buildVSeed: (options?: BuildVSeedOptions) => Promise<TSeedDSL>;
     buildVQuery: () => TQueryDSL;
-    build: () => VBIDSL;
+    build: () => VBIChartDSL;
     isEmpty: () => boolean;
 }

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

@@ -1,21 +1,23 @@
 import type { DefaultVBIQueryDSL, DefaultVBISeedDSL } from '../../builder/adapters/vquery-vseed/types';
 import type { Map } from 'yjs';
-import type { VBIDSL } from '../dsl';
-import type { VBIBuilderInterface } from './VBIInterface';
-export interface VBIBuildVQueryContext<TQueryDSL = DefaultVBIQueryDSL, TSeedDSL = DefaultVBISeedDSL> {
+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: VBIDSL;
-    builder: VBIBuilderInterface<TQueryDSL, TSeedDSL>;
+    vbiDSL: VBIChartDSL;
+    builder: VBIChartBuilderInterface<TQueryDSL, TSeedDSL>;
 }
-export interface VBIBuildVSeedContext<TQueryDSL = DefaultVBIQueryDSL, TSeedDSL = DefaultVBISeedDSL> extends VBIBuildVQueryContext<TQueryDSL, TSeedDSL> {
+export interface VBIChartBuildVSeedContext<TQueryDSL = DefaultVBIQueryDSL, TSeedDSL = DefaultVBISeedDSL> extends VBIChartBuildVQueryContext<TQueryDSL, TSeedDSL> {
+    options: BuildVSeedOptions;
     queryDSL: TQueryDSL;
 }
-export type VBIQueryBuilder<TQueryDSL = DefaultVBIQueryDSL, TSeedDSL = DefaultVBISeedDSL> = (context: VBIBuildVQueryContext<TQueryDSL, TSeedDSL>) => TQueryDSL;
-export type VBISeedBuilder<TQueryDSL = DefaultVBIQueryDSL, TSeedDSL = DefaultVBISeedDSL> = (context: VBIBuildVSeedContext<TQueryDSL, TSeedDSL>) => Promise<TSeedDSL> | TSeedDSL;
-export interface VBIBuilderAdapters<TQueryDSL = DefaultVBIQueryDSL, TSeedDSL = DefaultVBISeedDSL> {
-    buildVQuery: VBIQueryBuilder<TQueryDSL, TSeedDSL>;
-    buildVSeed: VBISeedBuilder<TQueryDSL, TSeedDSL>;
+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 VBIBuilderOptions<TQueryDSL = DefaultVBIQueryDSL, TSeedDSL = DefaultVBISeedDSL> {
-    adapters?: Partial<VBIBuilderAdapters<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,3 +1,4 @@
-export type { VBIBuilderInterface } from './VBIInterface';
-export type { VBIBuildVQueryContext, VBIBuildVSeedContext, VBIQueryBuilder, VBISeedBuilder, VBIBuilderAdapters, VBIBuilderOptions, } from './adapter';
-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

@@ -8,7 +8,7 @@ export type VBIHavingAggregate = z.infer<typeof zAggregate>;
 export declare const zVBIHavingFilter: z.ZodObject<{
     id: z.ZodString;
     field: z.ZodString;
-    aggregate: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    aggregate: z.ZodDiscriminatedUnion<[z.ZodObject<{
         func: z.ZodEnum<{
             count: "count";
             countDistinct: "countDistinct";
@@ -24,8 +24,8 @@ export declare const zVBIHavingFilter: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         func: z.ZodLiteral<"quantile">;
         quantile: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>], "func">>;
-    op: z.ZodOptional<z.ZodString>;
+    }, 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 { 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/measures.d.ts

@@ -1,15 +1,69 @@
 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.ZodEnum<{
@@ -28,6 +82,45 @@ export declare const zVBIMeasure: z.ZodObject<{
         func: z.ZodLiteral<"quantile">;
         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<{
@@ -35,12 +128,27 @@ 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.ZodEnum<{
@@ -59,6 +167,45 @@ export declare const zVBIMeasureTree: z.ZodArray<z.ZodUnion<readonly [z.ZodObjec
         func: z.ZodLiteral<"quantile">;
         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>;

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

@@ -1,23 +1,69 @@
 import { z } from 'zod';
-export declare const zVBIDSL: z.ZodObject<{
+export declare const zVBIChartDSL: z.ZodObject<{
     connectorId: z.ZodString;
     chartType: z.ZodCustom<any, any>;
     dimensions: 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<import("..").VBIDimensionGroup, unknown, z.core.$ZodTypeInternals<import("..").VBIDimensionGroup, unknown>>]>>;
     measures: z.ZodArray<z.ZodUnion<readonly [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.ZodEnum<{
@@ -36,6 +82,45 @@ export declare const zVBIDSL: z.ZodObject<{
             func: z.ZodLiteral<"quantile">;
             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<import("..").VBIMeasureGroup, unknown, z.core.$ZodTypeInternals<import("..").VBIMeasureGroup, unknown>>]>>;
     havingFilter: z.ZodDefault<z.ZodOptional<z.ZodType<{
         id: string;
@@ -78,5 +163,5 @@ export declare const zVBIDSL: z.ZodObject<{
     limit: z.ZodOptional<z.ZodNumber>;
     version: z.ZodNumber;
 }, z.core.$strip>;
-export type VBIDSLInput = z.input<typeof zVBIDSL>;
-export type VBIDSL = z.output<typeof zVBIDSL>;
+export type VBIChartDSLInput = z.input<typeof zVBIChartDSL>;
+export type VBIChartDSL = z.output<typeof zVBIChartDSL>;