@uipath/apollo-vertex 0.0.0-stage → 0.3.0

package/dist/registry/insights-adapter/chart-adapters/line.js

@@ -0,0 +1,98 @@
+import { queryOptions } from "@tanstack/react-query";
+import { DateTime } from "luxon";
+import { z } from "zod";
+import { assert } from "../../../lib/asserts/assert.js";
+import { assertDefined } from "../../../lib/asserts/assert-defined.js";
+import { mapConfigFilterToFilterValues } from "../../charts-core/charts-core.js";
+import { assertInsightsConfigurationSupported } from "../utils/assert-configuration-supported.js";
+import { calculateDatetimeBins, findBinCutoffPoints } from "../utils/binning.js";
+import { mapMetricToInsightsAggregate } from "../utils/metric-aggregate.js";
+import { insightsQuery } from "../utils/query.js";
+import { createInsightsChartQueryOptions } from "../utils/query-options.js";
+const insightsLineChartAdapter = (client, sourceType)=>(configuration, dataModel)=>{
+        assertInsightsConfigurationSupported(configuration);
+        const firstDimensionId = assertDefined(configuration.dimensions[0], "Line chart must have at least one dimension");
+        const firstDimension = assertDefined(dataModel.dimensions.find((d)=>d.id === firstDimensionId), `Dimension ${firstDimensionId} not found in dataModel`);
+        const firstMetricId = assertDefined(configuration.metrics[0], "Line chart must have at least one metric");
+        const firstMetric = assertDefined(dataModel.metrics.find((m)=>m.id === firstMetricId), `Metric ${firstMetricId} not found in dataModel`);
+        assert("datetime" === firstDimension.type, "Dimension type must be datetime");
+        const aggregate = mapMetricToInsightsAggregate(firstMetric);
+        const filters = (configuration.filters ?? []).map((f)=>mapConfigFilterToFilterValues(f));
+        const filterTableId = configuration.filterTableId;
+        const minMaxRequest = createInsightsChartQueryOptions({
+            groupBy: [],
+            aggregates: [
+                {
+                    id: "min",
+                    expression: {
+                        type: "aggregate",
+                        aggregation: "MIN",
+                        argument: firstDimension.id
+                    }
+                },
+                {
+                    id: "max",
+                    expression: {
+                        type: "aggregate",
+                        aggregation: "MAX",
+                        argument: firstDimension.id
+                    }
+                }
+            ],
+            sortBy: null,
+            filters,
+            filterTableId
+        });
+        return queryOptions({
+            queryKey: [
+                sourceType,
+                "line",
+                JSON.stringify(minMaxRequest),
+                JSON.stringify(aggregate)
+            ],
+            queryFn: async ()=>{
+                const response = await insightsQuery(client, sourceType, minMaxRequest, "Failed to fetch min/max");
+                const minStr = z.string().nullable().parse(response.min?.values?.[0] ?? null);
+                const maxStr = z.string().nullable().parse(response.max?.values?.[0] ?? null);
+                if (!minStr || !maxStr) return {
+                    values: [],
+                    bins: []
+                };
+                const min = DateTime.fromISO(minStr, {
+                    zone: "utc"
+                });
+                const max = DateTime.fromISO(maxStr, {
+                    zone: "utc"
+                });
+                const bins = calculateDatetimeBins({
+                    min,
+                    max
+                });
+                const cutoffPoints = findBinCutoffPoints(bins);
+                if (0 === cutoffPoints.length) return {
+                    values: [],
+                    bins: []
+                };
+                const binsRequest = createInsightsChartQueryOptions({
+                    groupBy: [],
+                    aggregates: [
+                        aggregate
+                    ],
+                    sortBy: null,
+                    filters,
+                    filterTableId,
+                    binning: {
+                        bins: cutoffPoints,
+                        dimension: firstDimension.id
+                    }
+                });
+                const dataResponse = await insightsQuery(client, sourceType, binsRequest, "Failed to fetch line chart data");
+                const values = dataResponse[aggregate.id]?.values?.map((value)=>z.number().nullable().parse(value) ?? 0) ?? [];
+                return {
+                    values,
+                    bins
+                };
+            }
+        });
+    };
+export { insightsLineChartAdapter };

package/dist/registry/insights-adapter/chart-adapters/multi-line.d.ts

@@ -0,0 +1,3 @@
+import { type DataAdapter } from "../../charts-core/charts-core";
+import { type InsightsClient } from "../utils/query";
+export declare const insightsMultiLineChartAdapter: (client: InsightsClient, sourceType: string) => DataAdapter["charts"]["multiLine"];

package/dist/registry/insights-adapter/chart-adapters/multi-line.js

@@ -0,0 +1,100 @@
+import { queryOptions } from "@tanstack/react-query";
+import { DateTime } from "luxon";
+import { z } from "zod";
+import { assert } from "../../../lib/asserts/assert.js";
+import { assertDefined } from "../../../lib/asserts/assert-defined.js";
+import { mapConfigFilterToFilterValues } from "../../charts-core/charts-core.js";
+import { assertInsightsConfigurationSupported } from "../utils/assert-configuration-supported.js";
+import { calculateDatetimeBins, findBinCutoffPoints } from "../utils/binning.js";
+import { mapMetricToInsightsAggregate } from "../utils/metric-aggregate.js";
+import { insightsQuery } from "../utils/query.js";
+import { createInsightsChartQueryOptions } from "../utils/query-options.js";
+const insightsMultiLineChartAdapter = (client, sourceType)=>(configuration, dataModel)=>{
+        assertInsightsConfigurationSupported(configuration);
+        const firstDimensionId = assertDefined(configuration.dimensions[0], "Multi line chart must have at least one dimension");
+        const firstDimension = assertDefined(dataModel.dimensions.find((d)=>d.id === firstDimensionId), `Dimension ${firstDimensionId} not found in dataModel`);
+        assert("datetime" === firstDimension.type, "Dimension type must be datetime");
+        const metrics = configuration.metrics.map((id)=>assertDefined(dataModel.metrics.find((m)=>m.id === id), `Metric ${id} not found in dataModel`));
+        const aggregates = metrics.map((m)=>mapMetricToInsightsAggregate(m));
+        const filters = (configuration.filters ?? []).map((f)=>mapConfigFilterToFilterValues(f));
+        const filterTableId = configuration.filterTableId;
+        const minMaxRequest = createInsightsChartQueryOptions({
+            groupBy: [],
+            aggregates: [
+                {
+                    id: "min",
+                    expression: {
+                        type: "aggregate",
+                        aggregation: "MIN",
+                        argument: firstDimension.id
+                    }
+                },
+                {
+                    id: "max",
+                    expression: {
+                        type: "aggregate",
+                        aggregation: "MAX",
+                        argument: firstDimension.id
+                    }
+                }
+            ],
+            sortBy: null,
+            filters,
+            filterTableId
+        });
+        return queryOptions({
+            queryKey: [
+                sourceType,
+                "multi-line",
+                JSON.stringify(minMaxRequest),
+                ...aggregates.map((a)=>JSON.stringify(a))
+            ],
+            queryFn: async ()=>{
+                const response = await insightsQuery(client, sourceType, minMaxRequest, "Failed to fetch min/max");
+                const minStr = z.string().nullable().parse(response.min?.values?.[0] ?? null);
+                const maxStr = z.string().nullable().parse(response.max?.values?.[0] ?? null);
+                if (!minStr || !maxStr) return {
+                    seriesByMetricId: {},
+                    bins: []
+                };
+                const min = DateTime.fromISO(minStr, {
+                    zone: "utc"
+                });
+                const max = DateTime.fromISO(maxStr, {
+                    zone: "utc"
+                });
+                const bins = calculateDatetimeBins({
+                    min,
+                    max
+                });
+                const cutoffPoints = findBinCutoffPoints(bins);
+                if (0 === cutoffPoints.length) return {
+                    seriesByMetricId: {},
+                    bins: []
+                };
+                const results = await Promise.all(aggregates.map((agg)=>insightsQuery(client, sourceType, createInsightsChartQueryOptions({
+                        groupBy: [],
+                        aggregates: [
+                            agg
+                        ],
+                        sortBy: null,
+                        filters,
+                        filterTableId,
+                        binning: {
+                            bins: cutoffPoints,
+                            dimension: firstDimension.id
+                        }
+                    }), "Failed to fetch multi-line chart data")));
+                const seriesByMetricId = {};
+                for (const [idx, agg] of aggregates.entries()){
+                    const dataResponse = assertDefined(results[idx], "Missing results for metric");
+                    seriesByMetricId[agg.id] = dataResponse[agg.id]?.values?.map((value)=>z.number().nullable().parse(value) ?? 0) ?? [];
+                }
+                return {
+                    seriesByMetricId,
+                    bins
+                };
+            }
+        });
+    };
+export { insightsMultiLineChartAdapter };

package/dist/registry/insights-adapter/chart-adapters/table.d.ts

@@ -0,0 +1,3 @@
+import { type DataAdapter } from "../../charts-core/charts-core";
+import { type InsightsClient } from "../utils/query";
+export declare const insightsTableChartAdapter: (client: InsightsClient, sourceType: string) => DataAdapter["charts"]["table"];

package/dist/registry/insights-adapter/chart-adapters/table.js

@@ -0,0 +1,30 @@
+import { queryOptions } from "@tanstack/react-query";
+import { mapConfigFilterToFilterValues, mapResponseToChartData } from "../../charts-core/charts-core.js";
+import { assertInsightsConfigurationSupported } from "../utils/assert-configuration-supported.js";
+import { insightsQuery } from "../utils/query.js";
+import { createInsightsChartQueryOptions } from "../utils/query-options.js";
+const insightsTableChartAdapter = (client, sourceType)=>(configuration, _dataModel, state)=>{
+        assertInsightsConfigurationSupported(configuration);
+        const dimensionIds = configuration.dimensions;
+        const requestBody = createInsightsChartQueryOptions({
+            groupBy: dimensionIds,
+            sortBy: state.sortBy,
+            filters: (configuration.filters ?? []).map((f)=>mapConfigFilterToFilterValues(f)),
+            filterTableId: configuration.filterTableId
+        });
+        return queryOptions({
+            queryKey: [
+                sourceType,
+                "table",
+                JSON.stringify(requestBody)
+            ],
+            queryFn: async ()=>{
+                const body = await insightsQuery(client, sourceType, requestBody, "Failed to fetch table data");
+                return mapResponseToChartData({
+                    data: body,
+                    dimensions: dimensionIds
+                });
+            }
+        });
+    };
+export { insightsTableChartAdapter };

package/dist/registry/insights-adapter/contract.d.ts

@@ -0,0 +1,225 @@
+import { z } from "zod";
+export declare const insightsContract: {
+    query: {
+        body: z.ZodObject<{
+            filters: z.ZodArray<z.ZodArray<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+                dimension: z.ZodString;
+                values: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber, z.ZodNull]>>;
+                type: z.ZodUnion<readonly [z.ZodLiteral<"string">, z.ZodLiteral<"boolean">, z.ZodLiteral<"numeric">]>;
+                kind: z.ZodLiteral<"values">;
+                invert: z.ZodBoolean;
+            }, z.core.$strip>, z.ZodObject<{
+                dimension: z.ZodString;
+                type: z.ZodLiteral<"datetime">;
+                range: z.ZodObject<{
+                    inclusive: z.ZodBoolean;
+                    start: z.ZodString;
+                    end: z.ZodString;
+                }, z.core.$strip>;
+                kind: z.ZodLiteral<"range">;
+            }, z.core.$strip>, z.ZodObject<{
+                dimension: z.ZodString;
+                type: z.ZodLiteral<"numeric">;
+                range: z.ZodObject<{
+                    inclusive: z.ZodBoolean;
+                    start: z.ZodOptional<z.ZodNumber>;
+                    end: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>;
+                kind: z.ZodLiteral<"range">;
+            }, z.core.$strip>, z.ZodObject<{
+                dimension: z.ZodString;
+                pattern: z.ZodString;
+                filterType: z.ZodUnion<readonly [z.ZodLiteral<"default">, z.ZodLiteral<"startsWith">, z.ZodLiteral<"endsWith">]>;
+                type: z.ZodLiteral<"string">;
+                kind: z.ZodLiteral<"search">;
+                invert: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>]>, z.ZodObject<{
+                kind: z.ZodLiteral<"tableWith">;
+                table: z.ZodString;
+                invert: z.ZodOptional<z.ZodBoolean>;
+                filters: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    dimension: z.ZodString;
+                    values: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber, z.ZodNull]>>;
+                    type: z.ZodUnion<readonly [z.ZodLiteral<"string">, z.ZodLiteral<"boolean">, z.ZodLiteral<"numeric">]>;
+                    kind: z.ZodLiteral<"values">;
+                    invert: z.ZodBoolean;
+                }, z.core.$strip>, z.ZodObject<{
+                    dimension: z.ZodString;
+                    type: z.ZodLiteral<"datetime">;
+                    range: z.ZodObject<{
+                        inclusive: z.ZodBoolean;
+                        start: z.ZodString;
+                        end: z.ZodString;
+                    }, z.core.$strip>;
+                    kind: z.ZodLiteral<"range">;
+                }, z.core.$strip>, z.ZodObject<{
+                    dimension: z.ZodString;
+                    type: z.ZodLiteral<"numeric">;
+                    range: z.ZodObject<{
+                        inclusive: z.ZodBoolean;
+                        start: z.ZodOptional<z.ZodNumber>;
+                        end: z.ZodOptional<z.ZodNumber>;
+                    }, z.core.$strip>;
+                    kind: z.ZodLiteral<"range">;
+                }, z.core.$strip>, z.ZodObject<{
+                    dimension: z.ZodString;
+                    pattern: z.ZodString;
+                    filterType: z.ZodUnion<readonly [z.ZodLiteral<"default">, z.ZodLiteral<"startsWith">, z.ZodLiteral<"endsWith">]>;
+                    type: z.ZodLiteral<"string">;
+                    kind: z.ZodLiteral<"search">;
+                    invert: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"primarykey">;
+                table: z.ZodString;
+            }, z.core.$strip>]>>>;
+            groupBy: z.ZodArray<z.ZodString>;
+            aggregates: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                expression: z.ZodUnion<readonly [z.ZodObject<{
+                    type: z.ZodLiteral<"aggregate">;
+                    aggregation: z.ZodEnum<{
+                        ANY: "ANY";
+                        DISTINCT_COUNT: "DISTINCT_COUNT";
+                        COUNT: "COUNT";
+                        AVERAGE: "AVERAGE";
+                        MIN: "MIN";
+                        MAX: "MAX";
+                        PERCENTAGE: "PERCENTAGE";
+                        SUM: "SUM";
+                        PERCENTILE: "PERCENTILE";
+                        MEDIAN: "MEDIAN";
+                        CASE_AVERAGE: "CASE_AVERAGE";
+                    }>;
+                    argument: z.ZodString;
+                    filters: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+                    percentileRank: z.ZodOptional<z.ZodObject<{
+                        kind: z.ZodLiteral<"Constant">;
+                        percentileRank: z.ZodNumber;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"operator">;
+                    operation: z.ZodEnum<{
+                        add: "add";
+                        multiply: "multiply";
+                        subtract: "subtract";
+                        percentage: "percentage";
+                        and: "and";
+                        or: "or";
+                        divide: "divide";
+                        eq: "eq";
+                        ne: "ne";
+                        gt: "gt";
+                        ge: "ge";
+                        lt: "lt";
+                        le: "le";
+                    }>;
+                    left: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                    right: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                }, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
+                    type: z.ZodLiteral<"constant">;
+                    value: z.ZodNumber;
+                    dataType: z.ZodEnum<{
+                        numeric: "numeric";
+                        duration: "duration";
+                        percentage: "percentage";
+                        currency: "currency";
+                    }>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"constant">;
+                    value: z.ZodString;
+                    dataType: z.ZodEnum<{
+                        datetime: "datetime";
+                        nominal: "nominal";
+                    }>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"constant">;
+                    value: z.ZodBoolean;
+                    dataType: z.ZodLiteral<"boolean">;
+                }, z.core.$strip>]>, z.ZodObject<{
+                    type: z.ZodLiteral<"reference">;
+                    reference: z.ZodString;
+                }, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
+                    type: z.ZodLiteral<"function">;
+                    function: z.ZodUnion<readonly [z.ZodLiteral<"isnull">, z.ZodLiteral<"isnotnull">]>;
+                    operand: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"function">;
+                    function: z.ZodLiteral<"not">;
+                    operand: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"function">;
+                    function: z.ZodLiteral<"if">;
+                    guard: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                    whenTrue: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                    whenFalse: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"function">;
+                    function: z.ZodLiteral<"substring">;
+                    expression: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                    start: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                    length: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"function">;
+                    function: z.ZodEnum<{
+                        left: "left";
+                        right: "right";
+                    }>;
+                    expression: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                    length: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"function">;
+                    function: z.ZodLiteral<"in">;
+                    value: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+                    list: z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"function">;
+                    function: z.ZodLiteral<"concat">;
+                    list: z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"function">;
+                    function: z.ZodLiteral<"coalesce">;
+                    list: z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+                }, z.core.$strip>]>]>;
+            }, z.core.$strip>>;
+            sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                field: z.ZodString;
+                direction: z.ZodEnum<{
+                    desc: "desc";
+                    asc: "asc";
+                }>;
+            }, z.core.$strip>>>;
+            binning: z.ZodOptional<z.ZodObject<{
+                bins: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+                dimension: z.ZodString;
+                extraBins: z.ZodEnum<{
+                    none: "none";
+                    null: "null";
+                }>;
+            }, z.core.$strip>>;
+            stacks: z.ZodOptional<z.ZodObject<{
+                field: z.ZodString;
+                orderByMetric: z.ZodString;
+                maxCount: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        method: "POST";
+        pathParams: z.ZodObject<{
+            sourceType: z.ZodString;
+        }, z.core.$strip>;
+        path: "/standalone-query/:sourceType";
+        responses: {
+            200: z.ZodRecord<z.ZodString, z.ZodObject<{
+                stackValues: z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodArray<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNullable<z.ZodNumber>]>, z.ZodObject<{
+                    type: z.ZodLiteral<"rest">;
+                }, z.core.$strip>]>>>>>;
+                ungrouped: z.ZodDefault<z.ZodUnion<readonly [z.ZodNullable<z.ZodNumber>, z.ZodArray<z.ZodNullable<z.ZodNumber>>]>>;
+                values: z.ZodNullable<z.ZodArray<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNullable<z.ZodNumber>]>, z.ZodArray<z.ZodNullable<z.ZodNumber>>]>>>;
+            }, z.core.$strip>>;
+            400: z.ZodObject<{
+                error: z.ZodString;
+            }, z.core.$strip>;
+        };
+        strictStatusCodes: true;
+    };
+};

package/dist/registry/insights-adapter/contract.js

@@ -0,0 +1,24 @@
+import { initContract } from "@ts-rest/core";
+import { z } from "zod";
+import { DataQueryResponseSchema } from "../charts-core/charts-core.js";
+import { InsightsQueryRequestSchema } from "./schemas/query-schema.js";
+const c = initContract();
+const insightsContract = c.router({
+    query: {
+        method: "POST",
+        path: "/standalone-query/:sourceType",
+        responses: {
+            200: DataQueryResponseSchema,
+            400: z.object({
+                error: z.string()
+            })
+        },
+        pathParams: z.object({
+            sourceType: z.string()
+        }),
+        body: InsightsQueryRequestSchema
+    }
+}, {
+    strictStatusCodes: true
+});
+export { insightsContract };

package/dist/registry/insights-adapter/insights-adapter.d.ts

@@ -0,0 +1,2 @@
+export { insightsAdapter } from "./adapter";
+export { insightsContract } from "./contract";

package/dist/registry/insights-adapter/insights-adapter.js

@@ -0,0 +1,3 @@
+import { insightsAdapter } from "./adapter.js";
+import { insightsContract } from "./contract.js";
+export { insightsAdapter, insightsContract };

package/dist/registry/insights-adapter/schemas/aggregate-fragment-schema.d.ts

@@ -0,0 +1,110 @@
+import { z } from "zod";
+export declare const AggregateFragmentSchema: z.ZodObject<{
+    id: z.ZodString;
+    expression: z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"aggregate">;
+        aggregation: z.ZodEnum<{
+            ANY: "ANY";
+            DISTINCT_COUNT: "DISTINCT_COUNT";
+            COUNT: "COUNT";
+            AVERAGE: "AVERAGE";
+            MIN: "MIN";
+            MAX: "MAX";
+            PERCENTAGE: "PERCENTAGE";
+            SUM: "SUM";
+            PERCENTILE: "PERCENTILE";
+            MEDIAN: "MEDIAN";
+            CASE_AVERAGE: "CASE_AVERAGE";
+        }>;
+        argument: z.ZodString;
+        filters: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+        percentileRank: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodLiteral<"Constant">;
+            percentileRank: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"operator">;
+        operation: z.ZodEnum<{
+            add: "add";
+            multiply: "multiply";
+            subtract: "subtract";
+            percentage: "percentage";
+            and: "and";
+            or: "or";
+            divide: "divide";
+            eq: "eq";
+            ne: "ne";
+            gt: "gt";
+            ge: "ge";
+            lt: "lt";
+            le: "le";
+        }>;
+        left: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        right: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"constant">;
+        value: z.ZodNumber;
+        dataType: z.ZodEnum<{
+            numeric: "numeric";
+            duration: "duration";
+            percentage: "percentage";
+            currency: "currency";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"constant">;
+        value: z.ZodString;
+        dataType: z.ZodEnum<{
+            datetime: "datetime";
+            nominal: "nominal";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"constant">;
+        value: z.ZodBoolean;
+        dataType: z.ZodLiteral<"boolean">;
+    }, z.core.$strip>]>, z.ZodObject<{
+        type: z.ZodLiteral<"reference">;
+        reference: z.ZodString;
+    }, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"function">;
+        function: z.ZodUnion<readonly [z.ZodLiteral<"isnull">, z.ZodLiteral<"isnotnull">]>;
+        operand: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"function">;
+        function: z.ZodLiteral<"not">;
+        operand: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"function">;
+        function: z.ZodLiteral<"if">;
+        guard: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        whenTrue: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        whenFalse: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"function">;
+        function: z.ZodLiteral<"substring">;
+        expression: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        start: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        length: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"function">;
+        function: z.ZodEnum<{
+            left: "left";
+            right: "right";
+        }>;
+        expression: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        length: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"function">;
+        function: z.ZodLiteral<"in">;
+        value: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        list: z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"function">;
+        function: z.ZodLiteral<"concat">;
+        list: z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"function">;
+        function: z.ZodLiteral<"coalesce">;
+        list: z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+    }, z.core.$strip>]>]>;
+}, z.core.$strip>;
+export type AggregateFragment = z.infer<typeof AggregateFragmentSchema>;