@uipath/apollo-vertex 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,157 @@
+import { z } from "zod";
+const AggregationKind = z["enum"]([
+    "ANY",
+    "DISTINCT_COUNT",
+    "COUNT",
+    "CASE_AVERAGE",
+    "AVERAGE",
+    "MIN",
+    "MAX",
+    "PERCENTAGE",
+    "SUM",
+    "MEDIAN",
+    "PERCENTILE"
+]);
+const AggregateSchema = z.object({
+    type: z.literal("aggregate"),
+    aggregation: AggregationKind,
+    argument: z.string(),
+    filters: z.array(z.any()).optional(),
+    percentileRank: z.object({
+        kind: z.literal("Constant"),
+        percentileRank: z.number()
+    }).optional()
+});
+const NumericConstantSchema = z.object({
+    type: z.literal("constant"),
+    value: z.number(),
+    dataType: z["enum"]([
+        "currency",
+        "numeric",
+        "percentage",
+        "duration"
+    ])
+});
+const StringConstantSchema = z.object({
+    type: z.literal("constant"),
+    value: z.string(),
+    dataType: z["enum"]([
+        "nominal",
+        "datetime"
+    ])
+});
+const BooleanConstantSchema = z.object({
+    type: z.literal("constant"),
+    value: z.boolean(),
+    dataType: z.literal("boolean")
+});
+const ConstantSchema = z.union([
+    NumericConstantSchema,
+    StringConstantSchema,
+    BooleanConstantSchema
+]);
+const OperandFragmentSchema = z.lazy(()=>z.union([
+        AggregateSchema,
+        ConstantSchema,
+        OperatorSchema,
+        ReferenceSchema,
+        FunctionSchema
+    ]));
+const OperatorSchema = z.object({
+    type: z.literal("operator"),
+    operation: z["enum"]([
+        "divide",
+        "percentage",
+        "multiply",
+        "subtract",
+        "add",
+        "eq",
+        "ne",
+        "gt",
+        "ge",
+        "lt",
+        "le",
+        "and",
+        "or"
+    ]),
+    left: OperandFragmentSchema,
+    right: OperandFragmentSchema
+});
+const ReferenceSchema = z.object({
+    type: z.literal("reference"),
+    reference: z.string()
+});
+const IsNullNotNullFunctionSchema = z.object({
+    type: z.literal("function"),
+    function: z.union([
+        z.literal("isnull"),
+        z.literal("isnotnull")
+    ]),
+    operand: OperandFragmentSchema
+});
+const IfThenFunctionSchema = z.object({
+    type: z.literal("function"),
+    function: z.literal("if"),
+    guard: OperandFragmentSchema,
+    whenTrue: OperandFragmentSchema,
+    whenFalse: OperandFragmentSchema.optional()
+});
+const NotFunctionSchema = z.object({
+    type: z.literal("function"),
+    function: z.literal("not"),
+    operand: OperandFragmentSchema
+});
+const LeftRightFunctionSchema = z.object({
+    type: z.literal("function"),
+    function: z["enum"]([
+        "left",
+        "right"
+    ]),
+    expression: OperandFragmentSchema,
+    length: OperandFragmentSchema
+});
+const SubstringFunctionSchema = z.object({
+    type: z.literal("function"),
+    function: z.literal("substring"),
+    expression: OperandFragmentSchema,
+    start: OperandFragmentSchema,
+    length: OperandFragmentSchema
+});
+const InFunctionSchema = z.object({
+    type: z.literal("function"),
+    function: z.literal("in"),
+    value: OperandFragmentSchema,
+    list: z.array(OperandFragmentSchema)
+});
+const ConcatFunctionSchema = z.object({
+    type: z.literal("function"),
+    function: z.literal("concat"),
+    list: z.array(OperandFragmentSchema)
+});
+const CoalesceFunctionSchema = z.object({
+    type: z.literal("function"),
+    function: z.literal("coalesce"),
+    list: z.array(OperandFragmentSchema)
+});
+const FunctionSchema = z.union([
+    IsNullNotNullFunctionSchema,
+    NotFunctionSchema,
+    IfThenFunctionSchema,
+    SubstringFunctionSchema,
+    LeftRightFunctionSchema,
+    InFunctionSchema,
+    ConcatFunctionSchema,
+    CoalesceFunctionSchema
+]);
+const ExpressionFragmentSchema = z.union([
+    AggregateSchema,
+    OperatorSchema,
+    ConstantSchema,
+    ReferenceSchema,
+    FunctionSchema
+]);
+const AggregateFragmentSchema = z.object({
+    id: z.string(),
+    expression: ExpressionFragmentSchema
+});
+export { AggregateFragmentSchema };

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

@@ -0,0 +1,74 @@
+import { z } from "zod";
+declare const ListFilterFragmentSchema: 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>;
+export type ListFilterFragment = z.infer<typeof ListFilterFragmentSchema>;
+declare const SearchFilterFragmentSchema: 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>;
+export type SearchFilterFragment = z.infer<typeof SearchFilterFragmentSchema>;
+declare const PeriodFilterFragmentSchema: 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>;
+export type PeriodFilterFragment = z.infer<typeof PeriodFilterFragmentSchema>;
+declare const RangeFilterFragmentSchema: 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>;
+export type RangeFilterFragment = z.infer<typeof RangeFilterFragmentSchema>;
+export declare const FilterFragmentSchema: 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>]>;
+export type FilterFragment = z.infer<typeof FilterFragmentSchema>;
+export {};

package/dist/registry/insights-adapter/schemas/filter-fragment-schema.js

@@ -0,0 +1,57 @@
+import { z } from "zod";
+const PrimitiveValueSchema = z.union([
+    z.string(),
+    z.boolean(),
+    z.number(),
+    z["null"]()
+]);
+const ListFilterFragmentSchema = z.object({
+    dimension: z.string(),
+    values: z.array(PrimitiveValueSchema),
+    type: z.union([
+        z.literal("string"),
+        z.literal("boolean"),
+        z.literal("numeric")
+    ]),
+    kind: z.literal("values"),
+    invert: z.boolean()
+});
+const SearchFilterFragmentSchema = z.object({
+    dimension: z.string(),
+    pattern: z.string(),
+    filterType: z.union([
+        z.literal("default"),
+        z.literal("startsWith"),
+        z.literal("endsWith")
+    ]),
+    type: z.literal("string"),
+    kind: z.literal("search"),
+    invert: z.boolean().optional()
+});
+const PeriodFilterFragmentSchema = z.object({
+    dimension: z.string(),
+    type: z.literal("datetime"),
+    range: z.object({
+        inclusive: z.boolean(),
+        start: z.string(),
+        end: z.string()
+    }),
+    kind: z.literal("range")
+});
+const RangeFilterFragmentSchema = z.object({
+    dimension: z.string(),
+    type: z.literal("numeric"),
+    range: z.object({
+        inclusive: z.boolean(),
+        start: z.number().optional(),
+        end: z.number().optional()
+    }),
+    kind: z.literal("range")
+});
+const FilterFragmentSchema = z.union([
+    ListFilterFragmentSchema,
+    PeriodFilterFragmentSchema,
+    RangeFilterFragmentSchema,
+    SearchFilterFragmentSchema
+]);
+export { FilterFragmentSchema };

package/dist/registry/insights-adapter/schemas/filter-request-schema.d.ts

@@ -0,0 +1,73 @@
+import { z } from "zod";
+export declare const FilterRequestSchema: 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>]>;
+export type FilterRequest = z.infer<typeof FilterRequestSchema>;

package/dist/registry/insights-adapter/schemas/filter-request-schema.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { FilterFragmentSchema } from "./filter-fragment-schema.js";
+const TableFragmentSchema = z.object({
+    kind: z.literal("tableWith"),
+    table: z.string(),
+    invert: z.boolean().optional(),
+    filters: z.array(FilterFragmentSchema)
+});
+const MainTableSchema = z.object({
+    kind: z.literal("primarykey"),
+    table: z.string()
+});
+const FilterRequestSchema = z.union([
+    FilterFragmentSchema,
+    TableFragmentSchema,
+    MainTableSchema
+]);
+export { FilterRequestSchema };

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

@@ -0,0 +1,204 @@
+import { z } from "zod";
+export declare const InsightsQueryRequestSchema: 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>;
+export type InsightsQueryRequest = z.infer<typeof InsightsQueryRequestSchema>;

package/dist/registry/insights-adapter/schemas/query-schema.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import { AggregateFragmentSchema } from "./aggregate-fragment-schema.js";
+import { FilterRequestSchema } from "./filter-request-schema.js";
+const InsightsQueryRequestSchema = z.object({
+    filters: z.array(z.array(FilterRequestSchema)),
+    groupBy: z.array(z.string()),
+    aggregates: z.array(AggregateFragmentSchema),
+    sort: z.array(z.object({
+        field: z.string(),
+        direction: z["enum"]([
+            "asc",
+            "desc"
+        ])
+    })).optional(),
+    binning: z.object({
+        bins: z.array(z.union([
+            z.string(),
+            z.number()
+        ])),
+        dimension: z.string(),
+        extraBins: z["enum"]([
+            "none",
+            "null"
+        ])
+    }).optional(),
+    stacks: z.object({
+        field: z.string(),
+        orderByMetric: z.string(),
+        maxCount: z.number()
+    }).optional()
+});
+export { InsightsQueryRequestSchema };

package/dist/registry/insights-adapter/utils/assert-configuration-supported.d.ts

@@ -0,0 +1,7 @@
+interface ConfigurationWithJoinsAndFrom {
+    id: string;
+    joins?: ReadonlyArray<unknown>;
+    from?: unknown;
+}
+export declare function assertInsightsConfigurationSupported(configuration: ConfigurationWithJoinsAndFrom): void;
+export {};

package/dist/registry/insights-adapter/utils/assert-configuration-supported.js

@@ -0,0 +1,5 @@
+function assertInsightsConfigurationSupported(configuration) {
+    if (configuration.joins && configuration.joins.length > 0) throw new Error(`Insights does not support joins (chart configuration "${configuration.id}").`);
+    if (configuration.from) throw new Error(`Insights does not support "from" (chart configuration "${configuration.id}").`);
+}
+export { assertInsightsConfigurationSupported };

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

@@ -0,0 +1,14 @@
+import { type DateTime, Interval } from "luxon";
+export interface NumericBin {
+    start: number;
+    end: number;
+}
+export declare function calculateDatetimeBins({ min, max, }: {
+    min: DateTime;
+    max: DateTime;
+}): Interval[];
+export declare function calculateNumericBins({ min, max, }: {
+    min: number;
+    max: number;
+}): NumericBin[];
+export declare function findBinCutoffPoints(bins: Array<Interval | NumericBin>): number[];