@dx-do/client 5.2.49 → 6.0.1

package/dist/src/lib/model/datastore/metrics-metadata/source-name-specifier.d.ts

@@ -0,0 +1,109 @@
+import { z } from 'zod/v4';
+/**
+ * Comparison operators used in the `PART` specifier for comparing
+ * dot-separated source-name segments numerically or lexically.
+ */
+declare const OperatorSchema: z.ZodEnum<{
+    GE: "GE";
+    GT: "GT";
+    LE: "LE";
+    LT: "LT";
+    EQ: "EQ";
+    NE: "NE";
+}>;
+/**
+ * `ALL` — matches every metric source name. Use as the broadest
+ * possible specifier; typically paired with `NOT` or nested inside
+ * an `AND` to subtract unwanted sources.
+ */
+declare const SourceNameAllSpecifierSchema: z.ZodObject<{
+    op: z.ZodLiteral<"ALL">;
+}, z.core.$loose>;
+/**
+ * `NONE` — matches no metric source name. Useful as a no-op placeholder
+ * when a specifier is structurally required but no sources should match.
+ */
+declare const SourceNameNoneSpecifierSchema: z.ZodObject<{
+    op: z.ZodLiteral<"NONE">;
+}, z.core.$loose>;
+/**
+ * `AND` — logical conjunction of child source-name specifiers.
+ * Only sources matched by ALL children are included.
+ * An empty `specifiers[]` is rejected by the server.
+ */
+declare const SourceNameAndSpecifierSchema: z.ZodObject<{
+    op: z.ZodLiteral<"AND">;
+    specifiers: z.ZodArray<z.ZodLazy<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+}, z.core.$loose>;
+/**
+ * `OR` — logical disjunction of child source-name specifiers.
+ * Sources matched by ANY child are included.
+ * An empty `specifiers[]` is rejected by the server.
+ */
+declare const SourceNameOrSpecifierSchema: z.ZodObject<{
+    op: z.ZodLiteral<"OR">;
+    specifiers: z.ZodArray<z.ZodLazy<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+}, z.core.$loose>;
+/**
+ * `NOT` — logical negation of a single child source-name specifier.
+ * Sources that do NOT match the child are included.
+ */
+declare const SourceNameNotSpecifierSchema: z.ZodObject<{
+    op: z.ZodLiteral<"NOT">;
+    specifier: z.ZodLazy<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+}, z.core.$loose>;
+/**
+ * `EXACT` — matches source names by exact string equality.
+ * Multiple `names` entries are OR-ed. `ignoreCase=true` enables
+ * case-insensitive matching.
+ */
+declare const SourceNameExactSpecifierSchema: z.ZodObject<{
+    op: z.ZodLiteral<"EXACT">;
+    names: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    ignoreCase: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+/**
+ * `REGEX` — matches source names where the full name satisfies `pattern`
+ * (Java regex). `ignoreCase` controls case sensitivity.
+ */
+declare const SourceNameRegExSpecifierSchema: z.ZodObject<{
+    op: z.ZodLiteral<"REGEX">;
+    pattern: z.ZodOptional<z.ZodString>;
+    ignoreCase: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+/**
+ * `PART` — matches source names by comparing a single dot-separated
+ * segment (0-indexed) against `partValue` using `operator`.
+ *
+ * For example, given source `"foo.bar.baz"`, `part=1` is `"bar"`.
+ * Useful for selecting by namespace segment without a full regex.
+ */
+declare const SourceNamePartOperatorSpecifierSchema: z.ZodObject<{
+    op: z.ZodLiteral<"PART">;
+    operator: z.ZodOptional<z.ZodEnum<{
+        GE: "GE";
+        GT: "GT";
+        LE: "LE";
+        LT: "LT";
+        EQ: "EQ";
+        NE: "NE";
+    }>>;
+    part: z.ZodNumber;
+    partValue: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+/**
+ * Discriminated union of all `SourceNameSpecifier` variants.
+ *
+ * Used inside `QuerySpecSpecifierSchema.sourceNameSpecifier` to filter
+ * metrics by their `source` dimension (e.g. `"foo.bar.baz"`).
+ *
+ * The boolean combinator variants (`AND`, `OR`, `NOT`) are recursive —
+ * build arbitrarily deep trees of inclusion/exclusion rules.
+ */
+export declare const SourceNameSpecifierSchema: z.ZodType;
+export interface SourceNameSpecifier {
+    op: string;
+    [key: string]: unknown;
+}
+export { SourceNameAllSpecifierSchema, SourceNameNoneSpecifierSchema, SourceNameAndSpecifierSchema, SourceNameOrSpecifierSchema, SourceNameNotSpecifierSchema, SourceNameExactSpecifierSchema, SourceNameRegExSpecifierSchema, SourceNamePartOperatorSpecifierSchema, OperatorSchema, };
+//# sourceMappingURL=source-name-specifier.d.ts.map

package/dist/src/lib/model/datastore/metrics-metadata/source-name-specifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-name-specifier.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/model/datastore/metrics-metadata/source-name-specifier.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAE3B;;;GAGG;AACH,QAAA,MAAM,cAAc;;;;;;;EAEmD,CAAC;AAExE;;;;GAIG;AACH,QAAA,MAAM,4BAA4B;;iBAEhC,CAAC;AAEH;;;GAGG;AACH,QAAA,MAAM,6BAA6B;;iBAEjC,CAAC;AAEH;;;;GAIG;AACH,QAAA,MAAM,4BAA4B;;;iBAOhC,CAAC;AAEH;;;;GAIG;AACH,QAAA,MAAM,2BAA2B;;;iBAO/B,CAAC;AAEH;;;GAGG;AACH,QAAA,MAAM,4BAA4B;;;iBAGhC,CAAC;AAEH;;;;GAIG;AACH,QAAA,MAAM,8BAA8B;;;;iBAIlC,CAAC;AAEH;;;GAGG;AACH,QAAA,MAAM,8BAA8B;;;;iBAIlC,CAAC;AAEH;;;;;;GAMG;AACH,QAAA,MAAM,qCAAqC;;;;;;;;;;;;iBAKzC,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,EAAE,CAAC,CAAC,OASxC,CAAC;AAEH,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,OAAO,EACL,4BAA4B,EAC5B,6BAA6B,EAC7B,4BAA4B,EAC5B,2BAA2B,EAC3B,4BAA4B,EAC5B,8BAA8B,EAC9B,8BAA8B,EAC9B,qCAAqC,EACrC,cAAc,GACf,CAAC"}

package/dist/src/lib/model/datastore/nassql/filter-specs.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod/v4';
+/**
+ * Numeric comparison operators for the `NUMERIC` predicate.
+ * - `EQ` — equal
+ * - `NE` — not equal
+ * - `LT` — less than
+ * - `LE` — less than or equal
+ * - `GT` — greater than
+ * - `GE` — greater than or equal
+ */
+export declare const NumericOperatorSchema: z.ZodEnum<{
+    GE: "GE";
+    GT: "GT";
+    LE: "LE";
+    LT: "LT";
+    EQ: "EQ";
+    NE: "NE";
+}>;
+export type NumericOperator = z.infer<typeof NumericOperatorSchema>;
+/**
+ * Open interface for the discriminated predicate union. Used to break
+ * circular-reference issues with `z.infer` on recursive Zod types.
+ */
+export interface QueryFilterPredicateSpec {
+    op: string;
+    [key: string]: unknown;
+}
+/**
+ * Discriminated union of all `FILTER` predicate types used in the
+ * `FILTER` op's `spec` field and recursively within `AND`/`OR`/`NOT`.
+ *
+ * Pick `FILTER_EXPR` (string grammar) for simpler hand-authored queries.
+ * Use the JSON predicate tree (`FILTER` + this union) for programmatic
+ * construction where individual conditions need to be composed.
+ */
+export declare const QueryFilterPredicateSpecSchema: z.ZodType;
+//# sourceMappingURL=filter-specs.d.ts.map

package/dist/src/lib/model/datastore/nassql/filter-specs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-specs.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/model/datastore/nassql/filter-specs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAE3B;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB;;;;;;;EAEuB,CAAC;AAC1D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE;;;GAGG;AACH,MAAM,WAAW,wBAAwB;IACvC,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAsFD;;;;;;;GAOG;AACH,eAAO,MAAM,8BAA8B,EAAE,CAAC,CAAC,OAQ7C,CAAC"}

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

@@ -0,0 +1,5 @@
+export * from './filter-specs';
+export * from './operations';
+export * from './query';
+export * from './response';
+//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -0,0 +1,506 @@
+import { z } from 'zod/v4';
+/**
+ * Time-window spec used by source ops (`FROM`, `FROM_DATA`, `FROM_METADATA`)
+ * and `JOIN_DATA` / `JOIN_METADATA`. Window is `[endTime - rangeSize, endTime]`.
+ *
+ * Defaults applied server-side when fields are omitted:
+ * - `endTime` → current time
+ * - `rangeSize` → 8 minutes (`8 * 60_000` ms)
+ * - `frequency` → 15 seconds (`15_000` ms) — the initial NASS aggregation interval
+ */
+export declare const QueryRangeSpecSchema: z.ZodObject<{
+    endTime: z.ZodNumber;
+    rangeSize: z.ZodNumber;
+    frequency: z.ZodNumber;
+}, z.core.$loose>;
+export type QueryRangeSpec = z.infer<typeof QueryRangeSpecSchema>;
+/**
+ * Direct list of metric IDs for `FROM_DATA`. Use when you already have
+ * specific metric IDs (typically from a previous `FROM_METADATA` step).
+ */
+export declare const QueryMetricIdSchema: z.ZodObject<{
+    metrics: z.ZodArray<z.ZodString>;
+}, z.core.$loose>;
+export type QueryMetricId = z.infer<typeof QueryMetricIdSchema>;
+/**
+ * Join semantics for `JOIN_METADATA` / `JOIN_TOPOLOGY`.
+ *
+ * - `INNER_JOIN` (default) — drop upstream rows with no match
+ * - `LEFT_OUTER_JOIN` — keep upstream rows; right-side columns become null when unmatched
+ */
+export declare const JoinTypeSchema: z.ZodEnum<{
+    INNER_JOIN: "INNER_JOIN";
+    LEFT_OUTER_JOIN: "LEFT_OUTER_JOIN";
+}>;
+export type JoinType = z.infer<typeof JoinTypeSchema>;
+/**
+ * Empty-window fill behavior on aggregations.
+ *
+ * - `MARK` (default) — emit one synthetic row marking the gap
+ * - `INNER` — fill all empty windows between non-empty windows
+ * - `ALL` — fill every empty window in the entire query range
+ */
+export declare const FillModeSchema: z.ZodEnum<{
+    ALL: "ALL";
+    INNER: "INNER";
+    MARK: "MARK";
+}>;
+export type FillMode = z.infer<typeof FillModeSchema>;
+/**
+ * Window alignment for `WINDOW`.
+ *
+ * - `ABSOLUTE` (default) — windows are epoch-aligned
+ * - `LEFT` — aligned to the query range start
+ * - `RIGHT` — aligned to the query range end
+ */
+export declare const AlignmentSchema: z.ZodEnum<{
+    LEFT: "LEFT";
+    RIGHT: "RIGHT";
+    ABSOLUTE: "ABSOLUTE";
+}>;
+export type Alignment = z.infer<typeof AlignmentSchema>;
+/**
+ * Calendar interval for `WINDOW_CALENDAR`. Calendar-aware boundaries
+ * (so MONTH respects month length, WEEK starts on Monday in the chosen
+ * zone, DST is honored for IANA zones).
+ */
+export declare const CalendarIntervalSchema: z.ZodEnum<{
+    MINUTE: "MINUTE";
+    HOUR: "HOUR";
+    DAY: "DAY";
+    WEEK: "WEEK";
+    MONTH: "MONTH";
+    QUARTER: "QUARTER";
+    YEAR: "YEAR";
+}>;
+export type CalendarInterval = z.infer<typeof CalendarIntervalSchema>;
+/**
+ * Quantile estimation method for `QUANTILE`.
+ *
+ * - `EXACT_INTERPOLATION` (default) — linearly interpolate between neighbors
+ * - `EXACT_SELECTOR` — pick the next-or-equal data value
+ */
+export declare const QuantileMethodSchema: z.ZodEnum<{
+    EXACT_INTERPOLATION: "EXACT_INTERPOLATION";
+    EXACT_SELECTOR: "EXACT_SELECTOR";
+}>;
+export type QuantileMethod = z.infer<typeof QuantileMethodSchema>;
+/** Output value type for `NASS_MAP` (`DOUBLE` default; forced to virtual-metric type when used inside a virtual metric). */
+export declare const NassValueTypeSchema: z.ZodEnum<{
+    DOUBLE: "DOUBLE";
+    LONG: "LONG";
+    STRING: "STRING";
+}>;
+export type NassValueType = z.infer<typeof NassValueTypeSchema>;
+/** Per-capture-group column type for `MAP_STRING.asType[]`; defaults to `STRING`. */
+export declare const QueryColumnTypeSpecSchema: z.ZodEnum<{
+    DOUBLE: "DOUBLE";
+    LONG: "LONG";
+    STRING: "STRING";
+}>;
+export type QueryColumnTypeSpec = z.infer<typeof QueryColumnTypeSpecSchema>;
+export declare const QueryFunctionSpecSchema: 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">;
+export type QueryFunctionSpec = z.infer<typeof QueryFunctionSpecSchema>;
+//# sourceMappingURL=operations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"operations.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/model/datastore/nassql/operations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAO3B;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB;;;;iBAY/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;iBAE9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;;;;GAKG;AACH,eAAO,MAAM,cAAc;;;EAA4C,CAAC;AACxE,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD;;;;;;GAMG;AACH,eAAO,MAAM,cAAc;;;;EAAmC,CAAC;AAC/D,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD;;;;;;GAMG;AACH,eAAO,MAAM,eAAe;;;;EAAwC,CAAC;AACrE,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD;;;;GAIG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;EAEjC,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;;;EAAoD,CAAC;AACtF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,4HAA4H;AAC5H,eAAO,MAAM,mBAAmB;;;;EAAuC,CAAC;AACxE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,qFAAqF;AACrF,eAAO,MAAM,yBAAyB;;;;EAAuC,CAAC;AAC9E,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AA8xB5E,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAwClC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC"}