@dx-do/client 5.2.48 → 5.2.50

package/dist/src/lib/model/datastore/nassql/query.d.ts

@@ -0,0 +1,419 @@
+import { z } from 'zod/v4';
+/**
+ * Top-level NASSQL query envelope sent to /metrics/nassQuery.
+ *
+ * A NASSQL query is a pipeline — an ordered array of operations where each
+ * op reads the row set produced by the previous one and emits a new row set.
+ * The first op must be a source (FROM_TOPOLOGY, FROM_METADATA, FROM_DATA,
+ * or the legacy FROM / SHOW_TABLES); subsequent ops transform, filter,
+ * aggregate, or join the rows.
+ */
+export declare const QueryRequestSchema: z.ZodObject<{
+    query: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        op: z.ZodLiteral<"FROM">;
+        querySpecifier: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        queryRange: z.ZodOptional<z.ZodObject<{
+            endTime: z.ZodNumber;
+            rangeSize: z.ZodNumber;
+            frequency: z.ZodNumber;
+        }, z.core.$loose>>;
+        queryHints: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            hint: z.ZodLiteral<"ForceRange">;
+        }, z.core.$loose>], "hint">>>;
+        alias: z.ZodOptional<z.ZodString>;
+        clampSize: z.ZodOptional<z.ZodNumber>;
+        rowsClampSize: z.ZodOptional<z.ZodNumber>;
+        metadataOnly: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>, z.ZodObject<{
+        op: z.ZodLiteral<"FROM_TABLE">;
+        tableName: z.ZodString;
+        alias: z.ZodOptional<z.ZodString>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        lowerBoundKey: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+        upperBoundKey: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    }, z.core.$loose>, z.ZodObject<{
+        op: z.ZodLiteral<"SHOW_TABLES">;
+    }, z.core.$loose>, z.ZodObject<{
+        op: z.ZodLiteral<"WINDOW">;
+        every: z.ZodNumber;
+        align: z.ZodOptional<z.ZodEnum<{
+            LEFT: "LEFT";
+            RIGHT: "RIGHT";
+            ABSOLUTE: "ABSOLUTE";
+        }>>;
+        incomplete: z.ZodOptional<z.ZodBoolean>;
+        useFrequency: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>, z.ZodObject<{
+        op: z.ZodLiteral<"WINDOW_CALENDAR">;
+        calendarInterval: z.ZodEnum<{
+            MINUTE: "MINUTE";
+            HOUR: "HOUR";
+            DAY: "DAY";
+            WEEK: "WEEK";
+            MONTH: "MONTH";
+            QUARTER: "QUARTER";
+            YEAR: "YEAR";
+        }>;
+        timeZone: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>, z.ZodObject<{
+        op: z.ZodLiteral<"GROUP">;
+        columns: z.ZodArray<z.ZodString>;
+    }, z.core.$loose>, z.ZodObject<{
+        op: z.ZodLiteral<"ORDER">;
+        columns: z.ZodArray<z.ZodObject<{
+            column: z.ZodString;
+            sortDescending: z.ZodBoolean;
+        }, z.core.$loose>>;
+        topN: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>, z.ZodObject<{
+        op: z.ZodLiteral<"KEEP">;
+        columns: z.ZodArray<z.ZodString>;
+        as: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$loose>, z.ZodObject<{
+        column: z.ZodOptional<z.ZodString>;
+        as: z.ZodOptional<z.ZodString>;
+        fillGaps: z.ZodOptional<z.ZodBoolean>;
+        fillValue: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+        fillMode: z.ZodOptional<z.ZodEnum<{
+            ALL: "ALL";
+            INNER: "INNER";
+            MARK: "MARK";
+        }>>;
+        op: z.ZodLiteral<"COUNT">;
+    }, z.core.$loose>, z.ZodObject<{
+        column: z.ZodString;
+        as: z.ZodOptional<z.ZodString>;
+        fillGaps: z.ZodOptional<z.ZodBoolean>;
+        fillValue: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+        fillMode: z.ZodOptional<z.ZodEnum<{
+            ALL: "ALL";
+            INNER: "INNER";
+            MARK: "MARK";
+        }>>;
+        op: z.ZodLiteral<"SUM">;
+    }, z.core.$loose>, z.ZodObject<{
+        column: z.ZodString;
+        as: z.ZodOptional<z.ZodString>;
+        fillGaps: z.ZodOptional<z.ZodBoolean>;
+        fillValue: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+        fillMode: z.ZodOptional<z.ZodEnum<{
+            ALL: "ALL";
+            INNER: "INNER";
+            MARK: "MARK";
+        }>>;
+        op: z.ZodLiteral<"MIN">;
+    }, z.core.$loose>, z.ZodObject<{
+        column: z.ZodString;
+        as: z.ZodOptional<z.ZodString>;
+        fillGaps: z.ZodOptional<z.ZodBoolean>;
+        fillValue: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+        fillMode: z.ZodOptional<z.ZodEnum<{
+            ALL: "ALL";
+            INNER: "INNER";
+            MARK: "MARK";
+        }>>;
+        op: z.ZodLiteral<"MAX">;
+    }, z.core.$loose>, z.ZodObject<{
+        column: z.ZodString;
+        as: z.ZodOptional<z.ZodString>;
+        weightColumn: z.ZodOptional<z.ZodString>;
+        fillGaps: z.ZodOptional<z.ZodBoolean>;
+        fillValue: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+        fillMode: z.ZodOptional<z.ZodEnum<{
+            ALL: "ALL";
+            INNER: "INNER";
+            MARK: "MARK";
+        }>>;
+        op: z.ZodLiteral<"MEAN">;
+    }, z.core.$loose>, z.ZodObject<{
+        spec: z.ZodArray<z.ZodObject<{
+            op: z.ZodOptional<z.ZodString>;
+            column: z.ZodOptional<z.ZodString>;
+            as: z.ZodOptional<z.ZodString>;
+            fromAlias: z.ZodOptional<z.ZodString>;
+            weightColumn: z.ZodOptional<z.ZodString>;
+            orderSrc: z.ZodOptional<z.ZodString>;
+            index: z.ZodOptional<z.ZodNumber>;
+            scale: z.ZodOptional<z.ZodNumber>;
+            method: z.ZodOptional<z.ZodEnum<{
+                EXACT_INTERPOLATION: "EXACT_INTERPOLATION";
+                EXACT_SELECTOR: "EXACT_SELECTOR";
+            }>>;
+            fillGaps: z.ZodOptional<z.ZodBoolean>;
+            fillValue: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+            fillMode: z.ZodOptional<z.ZodEnum<{
+                ALL: "ALL";
+                INNER: "INNER";
+                MARK: "MARK";
+            }>>;
+        }, z.core.$loose>>;
+        fillGaps: z.ZodOptional<z.ZodBoolean>;
+        fillValue: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+        fillMode: z.ZodOptional<z.ZodEnum<{
+            ALL: "ALL";
+            INNER: "INNER";
+            MARK: "MARK";
+        }>>;
+        op: z.ZodLiteral<"AGG">;
+    }, z.core.$loose>, z.ZodObject<{
+        op: z.ZodLiteral<"DERIVATIVE">;
+        column: z.ZodString;
+        unit: z.ZodOptional<z.ZodNumber>;
+        negative: z.ZodOptional<z.ZodBoolean>;
+        as: z.ZodOptional<z.ZodString>;
+        timeSrc: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>, z.ZodObject<{
+        op: z.ZodLiteral<"DIFFERENCE">;
+        column: z.ZodString;
+        negative: z.ZodOptional<z.ZodBoolean>;
+        as: z.ZodOptional<z.ZodString>;
+        timeSrc: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>, z.ZodObject<{
+        column: z.ZodString;
+        as: z.ZodOptional<z.ZodString>;
+        orderSrc: z.ZodOptional<z.ZodString>;
+        fillGaps: z.ZodOptional<z.ZodBoolean>;
+        fillValue: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+        fillMode: z.ZodOptional<z.ZodEnum<{
+            ALL: "ALL";
+            INNER: "INNER";
+            MARK: "MARK";
+        }>>;
+        op: z.ZodLiteral<"FIRST">;
+    }, z.core.$loose>, z.ZodObject<{
+        column: z.ZodString;
+        as: z.ZodOptional<z.ZodString>;
+        orderSrc: z.ZodOptional<z.ZodString>;
+        fillGaps: z.ZodOptional<z.ZodBoolean>;
+        fillValue: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+        fillMode: z.ZodOptional<z.ZodEnum<{
+            ALL: "ALL";
+            INNER: "INNER";
+            MARK: "MARK";
+        }>>;
+        op: z.ZodLiteral<"LAST">;
+    }, z.core.$loose>, z.ZodObject<{
+        column: z.ZodString;
+        as: z.ZodOptional<z.ZodString>;
+        method: z.ZodOptional<z.ZodEnum<{
+            EXACT_INTERPOLATION: "EXACT_INTERPOLATION";
+            EXACT_SELECTOR: "EXACT_SELECTOR";
+        }>>;
+        index: z.ZodNumber;
+        scale: z.ZodOptional<z.ZodNumber>;
+        fillGaps: z.ZodOptional<z.ZodBoolean>;
+        fillValue: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+        fillMode: z.ZodOptional<z.ZodEnum<{
+            ALL: "ALL";
+            INNER: "INNER";
+            MARK: "MARK";
+        }>>;
+        op: z.ZodLiteral<"QUANTILE">;
+    }, z.core.$loose>, z.ZodObject<{
+        fillGaps: z.ZodOptional<z.ZodBoolean>;
+        fillValue: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+        fillMode: z.ZodOptional<z.ZodEnum<{
+            ALL: "ALL";
+            INNER: "INNER";
+            MARK: "MARK";
+        }>>;
+        op: z.ZodLiteral<"DISTINCT">;
+    }, z.core.$loose>, z.ZodObject<{
+        op: z.ZodLiteral<"DESCRIBE">;
+    }, z.core.$loose>, z.ZodObject<{
+        op: z.ZodLiteral<"TOP">;
+        column: z.ZodString;
+        n: z.ZodNumber;
+        sortAscending: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>, z.ZodObject<{
+        op: z.ZodLiteral<"BOTTOM">;
+        column: z.ZodString;
+        n: z.ZodNumber;
+        sortAscending: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>, z.ZodObject<{
+        fromAlias: z.ZodOptional<z.ZodString>;
+        as: z.ZodOptional<z.ZodString>;
+        fillGaps: z.ZodOptional<z.ZodBoolean>;
+        fillValue: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+        fillMode: z.ZodOptional<z.ZodEnum<{
+            ALL: "ALL";
+            INNER: "INNER";
+            MARK: "MARK";
+        }>>;
+        op: z.ZodLiteral<"NASS_AGG">;
+    }, z.core.$loose>, z.ZodObject<{
+        op: z.ZodLiteral<"FILTER">;
+        spec: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }, z.core.$loose>, z.ZodObject<{
+        op: z.ZodLiteral<"FILTER_EXPR">;
+        spec: z.ZodString;
+    }, z.core.$loose>, z.ZodObject<{
+        op: z.ZodLiteral<"JOIN_DATA">;
+        queryRange: z.ZodOptional<z.ZodObject<{
+            endTime: z.ZodNumber;
+            rangeSize: z.ZodNumber;
+            frequency: z.ZodNumber;
+        }, z.core.$loose>>;
+        metricIdColumn: z.ZodString;
+        alias: z.ZodOptional<z.ZodString>;
+        joinFirstOnly: z.ZodOptional<z.ZodBoolean>;
+        rowsClampSize: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>, z.ZodObject<{
+        op: z.ZodLiteral<"FORMAT_TIME">;
+        column: z.ZodString;
+        as: z.ZodOptional<z.ZodString>;
+        duration: z.ZodOptional<z.ZodBoolean>;
+        pattern: z.ZodOptional<z.ZodString>;
+        timezone: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>, z.ZodObject<{
+        op: z.ZodLiteral<"FROM_METADATA">;
+        querySpecifier: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        queryRange: z.ZodOptional<z.ZodObject<{
+            endTime: z.ZodNumber;
+            rangeSize: z.ZodNumber;
+            frequency: z.ZodNumber;
+        }, z.core.$loose>>;
+        queryHints: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            hint: z.ZodLiteral<"ForceRange">;
+        }, z.core.$loose>], "hint">>>;
+        alias: z.ZodOptional<z.ZodString>;
+        rowsClampSize: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>, z.ZodObject<{
+        op: z.ZodLiteral<"FROM_TOPOLOGY">;
+        querySpecifier: z.ZodObject<{
+            version: z.ZodOptional<z.ZodString>;
+            time: z.ZodOptional<z.ZodNumber>;
+            schema: z.ZodOptional<z.ZodString>;
+            offset: z.ZodOptional<z.ZodNumber>;
+            limit: z.ZodOptional<z.ZodNumber>;
+            order: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodOptional<z.ZodString>;
+                comparator: z.ZodOptional<z.ZodEnum<{
+                    LEXICAL: "LEXICAL";
+                    NUMBER: "NUMBER";
+                    DATETIME: "DATETIME";
+                }>>;
+                caseInsensitive: z.ZodOptional<z.ZodBoolean>;
+                desc: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$loose>>>;
+            variables: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodOptional<z.ZodString>;
+                input: z.ZodOptional<z.ZodLazy<z.ZodType<import("..").TasFilter, unknown, z.core.$ZodTypeInternals<import("..").TasFilter, unknown>>>>;
+            }, z.core.$loose>>>;
+            filter: z.ZodOptional<z.ZodType<import("..").TasFilter, unknown, z.core.$ZodTypeInternals<import("..").TasFilter, unknown>>>;
+            universe: z.ZodOptional<z.ZodType<import("..").TasFilter, unknown, z.core.$ZodTypeInternals<import("..").TasFilter, unknown>>>;
+            authorizationView: z.ZodOptional<z.ZodString>;
+            postFilter: z.ZodOptional<z.ZodType<import("..").TasFilter, unknown, z.core.$ZodTypeInternals<import("..").TasFilter, unknown>>>;
+            stateFilter: z.ZodOptional<z.ZodType<import("../states").VertexStateFilter, unknown, z.core.$ZodTypeInternals<import("../states").VertexStateFilter, unknown>>>;
+            includeStatus: z.ZodOptional<z.ZodBoolean>;
+            includeServices: z.ZodOptional<z.ZodBoolean>;
+            includeProfile: z.ZodOptional<z.ZodBoolean>;
+            flushCacheBeforeQuery: z.ZodOptional<z.ZodBoolean>;
+            projection: z.ZodOptional<z.ZodEnum<{
+                DETAILED: "DETAILED";
+                BRIEF: "BRIEF";
+                NO_TYPE: "NO_TYPE";
+            }>>;
+            projectionFilter: z.ZodOptional<z.ZodObject<{
+                attributes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                attributeValueAsFields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    name: z.ZodOptional<z.ZodString>;
+                    pointer: z.ZodOptional<z.ZodString>;
+                    as: z.ZodOptional<z.ZodString>;
+                }, z.core.$loose>>>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>;
+        alias: z.ZodOptional<z.ZodString>;
+        rowsClampSize: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>, z.ZodObject<{
+        op: z.ZodLiteral<"FROM_DATA">;
+        querySpecifier: z.ZodObject<{
+            metrics: z.ZodArray<z.ZodString>;
+        }, z.core.$loose>;
+        queryRange: z.ZodOptional<z.ZodObject<{
+            endTime: z.ZodNumber;
+            rangeSize: z.ZodNumber;
+            frequency: z.ZodNumber;
+        }, z.core.$loose>>;
+        alias: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>, z.ZodObject<{
+        op: z.ZodLiteral<"JOIN_METADATA">;
+        querySpecifier: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        queryRange: z.ZodOptional<z.ZodObject<{
+            endTime: z.ZodNumber;
+            rangeSize: z.ZodNumber;
+            frequency: z.ZodNumber;
+        }, z.core.$loose>>;
+        queryHints: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            hint: z.ZodLiteral<"ForceRange">;
+        }, z.core.$loose>], "hint">>>;
+        alias: z.ZodOptional<z.ZodString>;
+        rowsClampSize: z.ZodOptional<z.ZodNumber>;
+        externalIdColumn: z.ZodOptional<z.ZodString>;
+        joinType: z.ZodOptional<z.ZodEnum<{
+            INNER_JOIN: "INNER_JOIN";
+            LEFT_OUTER_JOIN: "LEFT_OUTER_JOIN";
+        }>>;
+    }, z.core.$loose>, z.ZodObject<{
+        op: z.ZodLiteral<"JOIN_TOPOLOGY">;
+        rowsClampSize: z.ZodOptional<z.ZodNumber>;
+        externalIdColumn: z.ZodOptional<z.ZodString>;
+        joinType: z.ZodOptional<z.ZodEnum<{
+            INNER_JOIN: "INNER_JOIN";
+            LEFT_OUTER_JOIN: "LEFT_OUTER_JOIN";
+        }>>;
+    }, z.core.$loose>, z.ZodObject<{
+        op: z.ZodLiteral<"LOG">;
+        name: z.ZodOptional<z.ZodString>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        countRecords: z.ZodOptional<z.ZodBoolean>;
+        excludeFinalResult: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>, z.ZodObject<{
+        op: z.ZodLiteral<"NASS_MAP">;
+        type: z.ZodOptional<z.ZodEnum<{
+            DOUBLE: "DOUBLE";
+            LONG: "LONG";
+            STRING: "STRING";
+        }>>;
+        time: z.ZodOptional<z.ZodString>;
+        interval: z.ZodOptional<z.ZodUnknown>;
+        min: z.ZodOptional<z.ZodUnknown>;
+        max: z.ZodOptional<z.ZodUnknown>;
+        value: z.ZodOptional<z.ZodString>;
+        count: z.ZodOptional<z.ZodUnknown>;
+        frequency: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>, z.ZodObject<{
+        op: z.ZodLiteral<"MAP_STRING">;
+        column: z.ZodString;
+        pattern: z.ZodString;
+        as: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        asType: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            DOUBLE: "DOUBLE";
+            LONG: "LONG";
+            STRING: "STRING";
+        }>>>;
+        fillValues: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        filterNotMatching: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>, z.ZodObject<{
+        op: z.ZodLiteral<"MAP">;
+        fn: z.ZodString;
+        as: z.ZodString;
+    }, z.core.$loose>, z.ZodObject<{
+        op: z.ZodLiteral<"FORMAT">;
+        format: z.ZodString;
+        columns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        as: z.ZodOptional<z.ZodString>;
+        languageTag: z.ZodOptional<z.ZodString>;
+        fillFormatError: z.ZodOptional<z.ZodBoolean>;
+        fillValue: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>, z.ZodObject<{
+        op: z.ZodLiteral<"SCRIPT">;
+        script: z.ZodString;
+        inputColumns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        outputColumns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$loose>], "op">>;
+    authorizationView: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+export type QueryRequest = z.infer<typeof QueryRequestSchema>;
+//# sourceMappingURL=query.d.ts.map

package/dist/src/lib/model/datastore/nassql/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/model/datastore/nassql/query.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAI3B;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAY7B,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/src/lib/model/datastore/nassql/response.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod/v4';
+export declare const QueryResultSchema: z.ZodArray<z.ZodUnknown>;
+export type QueryResult = z.infer<typeof QueryResultSchema>;
+//# sourceMappingURL=response.d.ts.map

package/dist/src/lib/model/datastore/nassql/response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/model/datastore/nassql/response.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAE3B,eAAO,MAAM,iBAAiB,0BAAuB,CAAC;AACtD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/src/lib/model/datastore/states/filters.d.ts

@@ -0,0 +1,73 @@
+import { z } from 'zod/v4';
+export declare const VertexStateAllFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"ALL">;
+}, z.core.$loose>;
+export declare const VertexStateAndFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"AND">;
+    input: z.ZodOptional<z.ZodArray<z.ZodLazy<z.ZodType<VertexStateFilter, unknown, z.core.$ZodTypeInternals<VertexStateFilter, unknown>>>>>;
+}, z.core.$loose>;
+export declare const VertexStateOrFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"OR">;
+    input: z.ZodOptional<z.ZodArray<z.ZodLazy<z.ZodType<VertexStateFilter, unknown, z.core.$ZodTypeInternals<VertexStateFilter, unknown>>>>>;
+}, z.core.$loose>;
+export declare const VertexStateAlertFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"ALERT">;
+    input: z.ZodOptional<z.ZodLazy<z.ZodType<VertexStateFilter, unknown, z.core.$ZodTypeInternals<VertexStateFilter, unknown>>>>;
+    not: z.ZodOptional<z.ZodBoolean>;
+    alertId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    alertExternalId: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
+export declare const VertexStateMetricFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"METRIC">;
+    input: z.ZodOptional<z.ZodLazy<z.ZodType<VertexStateFilter, unknown, z.core.$ZodTypeInternals<VertexStateFilter, unknown>>>>;
+    not: z.ZodOptional<z.ZodBoolean>;
+    metricId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    metricExternalId: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
+export declare const VertexStateStateFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"STATE">;
+    input: z.ZodOptional<z.ZodLazy<z.ZodType<VertexStateFilter, unknown, z.core.$ZodTypeInternals<VertexStateFilter, unknown>>>>;
+    not: z.ZodOptional<z.ZodBoolean>;
+    state: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+}, z.core.$loose>;
+export declare const VertexStateVertexIdFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"VERTEX_ID">;
+    input: z.ZodOptional<z.ZodLazy<z.ZodType<VertexStateFilter, unknown, z.core.$ZodTypeInternals<VertexStateFilter, unknown>>>>;
+    not: z.ZodOptional<z.ZodBoolean>;
+    vertexId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+}, z.core.$loose>;
+export declare const VertexStateNamespaceFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"NAMESPACE">;
+    input: z.ZodOptional<z.ZodLazy<z.ZodType<VertexStateFilter, unknown, z.core.$ZodTypeInternals<VertexStateFilter, unknown>>>>;
+    not: z.ZodOptional<z.ZodBoolean>;
+    namespaces: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
+export declare const VertexStateManagementModuleFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"MANAGEMENT_MODULE">;
+    input: z.ZodOptional<z.ZodLazy<z.ZodType<VertexStateFilter, unknown, z.core.$ZodTypeInternals<VertexStateFilter, unknown>>>>;
+    not: z.ZodOptional<z.ZodBoolean>;
+    moduleNames: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
+export declare const VertexStateEmptyFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"EMPTY">;
+    input: z.ZodOptional<z.ZodLazy<z.ZodType<VertexStateFilter, unknown, z.core.$ZodTypeInternals<VertexStateFilter, unknown>>>>;
+}, z.core.$loose>;
+export declare const VertexGroupSchema: z.ZodObject<{
+    groupName: z.ZodString;
+    vertexIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+}, z.core.$loose>;
+export type VertexGroup = z.infer<typeof VertexGroupSchema>;
+export declare const VertexStateCollectVertexGroupStatusFilterSchema: z.ZodObject<{
+    op: z.ZodLiteral<"COLLECT_GROUPS">;
+    input: z.ZodOptional<z.ZodLazy<z.ZodType<VertexStateFilter, unknown, z.core.$ZodTypeInternals<VertexStateFilter, unknown>>>>;
+    groups: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        groupName: z.ZodString;
+        vertexIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+export declare const VertexStateFilterSchema: z.ZodType<VertexStateFilter>;
+export interface VertexStateFilter {
+    op: string;
+    [key: string]: unknown;
+}
+//# sourceMappingURL=filters.d.ts.map

package/dist/src/lib/model/datastore/states/filters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filters.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/model/datastore/states/filters.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAI3B,eAAO,MAAM,0BAA0B;;iBAErC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;iBAGrC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;iBAGpC,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;;;;iBAMvC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;iBAMxC,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;;;iBAKvC,CAAC;AAEH,eAAO,MAAM,+BAA+B;;;;;iBAK1C,CAAC;AAEH,eAAO,MAAM,gCAAgC;;;;;iBAK3C,CAAC;AAEH,eAAO,MAAM,uCAAuC;;;;;iBAKlD,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;iBAGvC,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;iBAG5B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,eAAO,MAAM,+CAA+C;;;;;;;iBAI1D,CAAC;AAEH,eAAO,MAAM,uBAAuB,EAAE,CAAC,CAAC,OAAO,CAAC,iBAAiB,CAY/D,CAAC;AAEH,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB"}

package/dist/src/lib/model/datastore/states/index.d.ts

@@ -0,0 +1,4 @@
+export * from './filters';
+export * from './query';
+export * from './response';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/lib/model/datastore/states/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/model/datastore/states/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC"}

package/dist/src/lib/model/datastore/states/query.d.ts

@@ -0,0 +1,106 @@
+import { z } from 'zod/v4';
+export declare const VertexStateProjectionSchema: z.ZodEnum<{
+    DETAILED: "DETAILED";
+    BRIEF: "BRIEF";
+    EXTRA_IDS: "EXTRA_IDS";
+}>;
+export type VertexStateProjection = z.infer<typeof VertexStateProjectionSchema>;
+export declare const VertexStateExternalIdInputSchema: z.ZodObject<{
+    vertexId: z.ZodOptional<z.ZodNumber>;
+    vertexExternalId: z.ZodOptional<z.ZodString>;
+    alert: z.ZodOptional<z.ZodString>;
+    alertExternalId: z.ZodOptional<z.ZodString>;
+    metric: z.ZodOptional<z.ZodString>;
+    metricExternalId: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type VertexStateExternalIdInput = z.infer<typeof VertexStateExternalIdInputSchema>;
+export declare const VertexStateInputSchema: z.ZodObject<{
+    stateExternalId: z.ZodOptional<z.ZodObject<{
+        vertexId: z.ZodOptional<z.ZodNumber>;
+        vertexExternalId: z.ZodOptional<z.ZodString>;
+        alert: z.ZodOptional<z.ZodString>;
+        alertExternalId: z.ZodOptional<z.ZodString>;
+        metric: z.ZodOptional<z.ZodString>;
+        metricExternalId: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    vertexId: z.ZodOptional<z.ZodNumber>;
+    alertId: z.ZodOptional<z.ZodNumber>;
+    metricId: z.ZodOptional<z.ZodNumber>;
+    startTime: z.ZodOptional<z.ZodNumber>;
+    endTime: z.ZodOptional<z.ZodNumber>;
+    status: z.ZodOptional<z.ZodNumber>;
+    data: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$loose>;
+export type VertexStateInput = z.infer<typeof VertexStateInputSchema>;
+export declare const VertexStateStoreRequestSchema: z.ZodObject<{
+    states: z.ZodArray<z.ZodObject<{
+        stateExternalId: z.ZodOptional<z.ZodObject<{
+            vertexId: z.ZodOptional<z.ZodNumber>;
+            vertexExternalId: z.ZodOptional<z.ZodString>;
+            alert: z.ZodOptional<z.ZodString>;
+            alertExternalId: z.ZodOptional<z.ZodString>;
+            metric: z.ZodOptional<z.ZodString>;
+            metricExternalId: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
+        vertexId: z.ZodOptional<z.ZodNumber>;
+        alertId: z.ZodOptional<z.ZodNumber>;
+        metricId: z.ZodOptional<z.ZodNumber>;
+        startTime: z.ZodOptional<z.ZodNumber>;
+        endTime: z.ZodOptional<z.ZodNumber>;
+        status: z.ZodOptional<z.ZodNumber>;
+        data: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export type VertexStateStoreRequest = z.infer<typeof VertexStateStoreRequestSchema>;
+export declare const VertexStateFetchRequestSchema: z.ZodObject<{
+    filter: z.ZodOptional<z.ZodType<import("./filters").VertexStateFilter, unknown, z.core.$ZodTypeInternals<import("./filters").VertexStateFilter, unknown>>>;
+    time: z.ZodOptional<z.ZodNumber>;
+    projection: z.ZodOptional<z.ZodEnum<{
+        DETAILED: "DETAILED";
+        BRIEF: "BRIEF";
+        EXTRA_IDS: "EXTRA_IDS";
+    }>>;
+    flushCacheBeforeQuery: z.ZodOptional<z.ZodBoolean>;
+    version: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    includeAllTouchedVertexStates: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+export type VertexStateFetchRequest = z.infer<typeof VertexStateFetchRequestSchema>;
+export declare const VertexStateClampSettingSchema: z.ZodObject<{
+    clampThreshold: z.ZodOptional<z.ZodNumber>;
+    bucketCount: z.ZodOptional<z.ZodNumber>;
+    bucketSize: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+export type VertexStateClampSetting = z.infer<typeof VertexStateClampSettingSchema>;
+export declare const VertexStateRangeRequestSchema: z.ZodObject<{
+    filter: z.ZodOptional<z.ZodType<import("./filters").VertexStateFilter, unknown, z.core.$ZodTypeInternals<import("./filters").VertexStateFilter, unknown>>>;
+    startTime: z.ZodOptional<z.ZodNumber>;
+    endTime: z.ZodOptional<z.ZodNumber>;
+    projection: z.ZodOptional<z.ZodEnum<{
+        DETAILED: "DETAILED";
+        BRIEF: "BRIEF";
+        EXTRA_IDS: "EXTRA_IDS";
+    }>>;
+    viewPortStart: z.ZodOptional<z.ZodNumber>;
+    viewPortEnd: z.ZodOptional<z.ZodNumber>;
+    clampSetting: z.ZodOptional<z.ZodObject<{
+        clampThreshold: z.ZodOptional<z.ZodNumber>;
+        bucketCount: z.ZodOptional<z.ZodNumber>;
+        bucketSize: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>;
+    flushCacheBeforeQuery: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+export type VertexStateRangeRequest = z.infer<typeof VertexStateRangeRequestSchema>;
+export declare const VertexStateRepublishRequestSchema: z.ZodObject<{
+    filter: z.ZodOptional<z.ZodType<import("./filters").VertexStateFilter, unknown, z.core.$ZodTypeInternals<import("./filters").VertexStateFilter, unknown>>>;
+    time: z.ZodOptional<z.ZodNumber>;
+    projection: z.ZodOptional<z.ZodEnum<{
+        DETAILED: "DETAILED";
+        BRIEF: "BRIEF";
+        EXTRA_IDS: "EXTRA_IDS";
+    }>>;
+    flushCacheBeforeQuery: z.ZodOptional<z.ZodBoolean>;
+    version: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    includeAllTouchedVertexStates: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+export type VertexStateRepublishRequest = z.infer<typeof VertexStateRepublishRequestSchema>;
+//# sourceMappingURL=query.d.ts.map

package/dist/src/lib/model/datastore/states/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/model/datastore/states/query.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAI3B,eAAO,MAAM,2BAA2B;;;;EAItC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,eAAO,MAAM,gCAAgC;;;;;;;iBAO3C,CAAC;AAEH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,gCAAgC,CACxC,CAAC;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;iBASjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;iBAExC,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC;AAEF,eAAO,MAAM,6BAA6B;;;;;;;;;;;iBAOxC,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC;AAEF,eAAO,MAAM,6BAA6B;;;;iBAIxC,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC;AAEF,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;iBASxC,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC;AAEF,eAAO,MAAM,iCAAiC;;;;;;;;;;;iBAAgC,CAAC;AAE/E,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAC/C,OAAO,iCAAiC,CACzC,CAAC"}