@dx-do/client 5.2.49 → 5.2.50

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

@@ -0,0 +1,201 @@
+import { z } from 'zod/v4';
+/**
+ * An attribute expression used in `ATTRIBUTE` specifiers and in the
+ * top-level Metadata `QueryAttributeSpecifier`. It matches metrics that
+ * have attribute `name` with a value satisfying `operator` against `values`.
+ *
+ * - `operator` defaults to `IN` (value must be in the list).
+ * - `comparator` controls how `values` are compared: `LEXICAL` (default),
+ *   `NUMBER`, or `DATETIME`.
+ * - `caseInsensitive=true` relaxes string matching.
+ */
+declare const QueryAttributeExpressionSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    values: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    operator: z.ZodOptional<z.ZodEnum<{
+        IN: "IN";
+        NOT_IN: "NOT_IN";
+        MATCHES: "MATCHES";
+        NOT_MATCHES: "NOT_MATCHES";
+        GE: "GE";
+        GT: "GT";
+        LE: "LE";
+        LT: "LT";
+    }>>;
+    comparator: z.ZodOptional<z.ZodEnum<{
+        LEXICAL: "LEXICAL";
+        NUMBER: "NUMBER";
+        DATETIME: "DATETIME";
+    }>>;
+    caseInsensitive: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+/**
+ * `ALL` — matches every attribute name.
+ */
+declare const AttributeNameAllSpecifierSchema: z.ZodObject<{
+    op: z.ZodLiteral<"ALL">;
+}, z.core.$loose>;
+/**
+ * `NONE` — matches no attribute name.
+ */
+declare const AttributeNameNoneSpecifierSchema: z.ZodObject<{
+    op: z.ZodLiteral<"NONE">;
+}, z.core.$loose>;
+/**
+ * `AND` — logical conjunction of child attribute-name specifiers.
+ * An empty `specifiers[]` is rejected by the server.
+ */
+declare const AttributeNameAndSpecifierSchema: 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 attribute-name specifiers.
+ * An empty `specifiers[]` is rejected by the server.
+ */
+declare const AttributeNameOrSpecifierSchema: 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 child attribute-name specifier.
+ */
+declare const AttributeNameNotSpecifierSchema: z.ZodObject<{
+    op: z.ZodLiteral<"NOT">;
+    specifier: z.ZodLazy<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+}, z.core.$loose>;
+/**
+ * `EXACT` — matches attribute names by exact string equality. Multiple
+ * `names` are OR-ed. `type` filters by attribute type bitmask
+ * (rare; prefer `TYPE` specifier for type filtering). `ignoreCase`
+ * enables case-insensitive matching.
+ */
+declare const AttributeNameExactSpecifierSchema: z.ZodObject<{
+    op: z.ZodLiteral<"EXACT">;
+    names: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    type: z.ZodOptional<z.ZodNumber>;
+    ignoreCase: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+/**
+ * `REGEX` — matches attribute names where the full name satisfies
+ * `pattern` (Java regex). `ignoreCase` controls case sensitivity.
+ */
+declare const AttributeNameRegExSpecifierSchema: z.ZodObject<{
+    op: z.ZodLiteral<"REGEX">;
+    pattern: z.ZodOptional<z.ZodString>;
+    ignoreCase: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+/**
+ * `FOLDER` — matches attribute names within a specific folder hierarchy.
+ * The nested `FolderNameSpecifier` selects the folder(s). Combine with
+ * `CHILDREN` for recursive descent.
+ */
+declare const AttributeNameFolderSpecifierSchema: z.ZodObject<{
+    op: z.ZodLiteral<"FOLDER">;
+    specifier: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+}, z.core.$loose>;
+/**
+ * `CHILDREN` — matches attribute names that are direct children of `prefix`,
+ * or all descendants when `recursive=true`. Prefix uses dot-separated
+ * path notation (e.g. `"my.namespace"`).
+ */
+declare const AttributeNameChildrenSpecifierSchema: z.ZodObject<{
+    op: z.ZodLiteral<"CHILDREN">;
+    prefix: z.ZodOptional<z.ZodString>;
+    recursive: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+/**
+ * `TYPE` — filters attribute names by their numeric type bitmask.
+ * `bitMask` selects the relevant bits; `bitMatch` specifies the
+ * expected bit pattern; `operator` controls the comparison mode.
+ * An optional inner `specifier` further narrows the set.
+ *
+ * This is a low-level attribute-type selector; most queries should use
+ * `NUMERIC` instead to select all numeric-typed attributes.
+ */
+declare const AttributeNameTypeSpecifierSchema: z.ZodObject<{
+    op: z.ZodLiteral<"TYPE">;
+    specifier: z.ZodOptional<z.ZodLazy<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+    bitMask: z.ZodOptional<z.ZodNumber>;
+    bitMatch: z.ZodOptional<z.ZodNumber>;
+    operator: z.ZodOptional<z.ZodEnum<{
+        GE: "GE";
+        GT: "GT";
+        LE: "LE";
+        LT: "LT";
+        EQ: "EQ";
+        NE: "NE";
+    }>>;
+}, z.core.$loose>;
+/**
+ * `OPERATOR` — matches attribute names by the name of their registered
+ * aggregation operator (e.g. `"LAST"`, `"SUM"`). `fullPath=true`
+ * requires an exact match of the full operator path; `false` matches
+ * the last segment.
+ */
+declare const AttributeNameOperatorSpecifierSchema: z.ZodObject<{
+    op: z.ZodLiteral<"OPERATOR">;
+    name: z.ZodOptional<z.ZodString>;
+    fullPath: z.ZodOptional<z.ZodBoolean>;
+    operator: z.ZodOptional<z.ZodEnum<{
+        GE: "GE";
+        GT: "GT";
+        LE: "LE";
+        LT: "LT";
+        EQ: "EQ";
+        NE: "NE";
+    }>>;
+}, z.core.$loose>;
+/**
+ * `NUMERIC` — matches any attribute that has a numeric data type.
+ * A convenience alias for a `TYPE` specifier with the numeric bitmask;
+ * use when you want all numeric attributes without specifying the exact
+ * bitmask.
+ */
+declare const AttributeNameAnyNumericSpecifierSchema: z.ZodObject<{
+    op: z.ZodLiteral<"NUMERIC">;
+}, z.core.$loose>;
+/**
+ * `ATTRIBUTE` — matches metrics that carry attribute value expressions
+ * satisfying `expressions`. Each expression tests one attribute by name.
+ * Multiple expressions are AND-ed implicitly.
+ */
+declare const AttributeNameAttributeSpecifierSchema: z.ZodObject<{
+    op: z.ZodLiteral<"ATTRIBUTE">;
+    expressions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        values: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        operator: z.ZodOptional<z.ZodEnum<{
+            IN: "IN";
+            NOT_IN: "NOT_IN";
+            MATCHES: "MATCHES";
+            NOT_MATCHES: "NOT_MATCHES";
+            GE: "GE";
+            GT: "GT";
+            LE: "LE";
+            LT: "LT";
+        }>>;
+        comparator: z.ZodOptional<z.ZodEnum<{
+            LEXICAL: "LEXICAL";
+            NUMBER: "NUMBER";
+            DATETIME: "DATETIME";
+        }>>;
+        caseInsensitive: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+/**
+ * Discriminated union of all `AttributeNameSpecifier` variants.
+ *
+ * Used inside `QuerySpecSpecifierSchema.attributeNameSpecifier` to
+ * filter the set of metric attribute names returned by a Metadata query.
+ * This determines which attribute columns appear in the response's
+ * `attributeNames` / `attributeMap` fields.
+ */
+export declare const AttributeNameSpecifierSchema: z.ZodType;
+export interface AttributeNameSpecifier {
+    op: string;
+    [key: string]: unknown;
+}
+export type QueryAttributeExpression = z.infer<typeof QueryAttributeExpressionSchema>;
+export { QueryAttributeExpressionSchema, AttributeNameAllSpecifierSchema, AttributeNameNoneSpecifierSchema, AttributeNameAndSpecifierSchema, AttributeNameOrSpecifierSchema, AttributeNameNotSpecifierSchema, AttributeNameExactSpecifierSchema, AttributeNameRegExSpecifierSchema, AttributeNameFolderSpecifierSchema, AttributeNameChildrenSpecifierSchema, AttributeNameTypeSpecifierSchema, AttributeNameOperatorSpecifierSchema, AttributeNameAnyNumericSpecifierSchema, AttributeNameAttributeSpecifierSchema, };
+//# sourceMappingURL=attribute-name-specifier.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"attribute-name-specifier.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/model/datastore/metrics-metadata/attribute-name-specifier.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAI3B;;;;;;;;;GASG;AACH,QAAA,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;iBAYlC,CAAC;AAEH;;GAEG;AACH,QAAA,MAAM,+BAA+B;;iBAEnC,CAAC;AAEH;;GAEG;AACH,QAAA,MAAM,gCAAgC;;iBAEpC,CAAC;AAEH;;;GAGG;AACH,QAAA,MAAM,+BAA+B;;;iBAOnC,CAAC;AAEH;;;GAGG;AACH,QAAA,MAAM,8BAA8B;;;iBAOlC,CAAC;AAEH;;GAEG;AACH,QAAA,MAAM,+BAA+B;;;iBAGnC,CAAC;AAEH;;;;;GAKG;AACH,QAAA,MAAM,iCAAiC;;;;;iBAKrC,CAAC;AAEH;;;GAGG;AACH,QAAA,MAAM,iCAAiC;;;;iBAIrC,CAAC;AAEH;;;;GAIG;AACH,QAAA,MAAM,kCAAkC;;;iBAKtC,CAAC;AAEH;;;;GAIG;AACH,QAAA,MAAM,oCAAoC;;;;iBAIxC,CAAC;AAEH;;;;;;;;GAQG;AACH,QAAA,MAAM,gCAAgC;;;;;;;;;;;;;iBAMpC,CAAC;AAEH;;;;;GAKG;AACH,QAAA,MAAM,oCAAoC;;;;;;;;;;;;iBAKxC,CAAC;AAEH;;;;;GAKG;AACH,QAAA,MAAM,sCAAsC;;iBAE1C,CAAC;AAEH;;;;GAIG;AACH,QAAA,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;iBAMzC,CAAC;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,4BAA4B,EAAE,CAAC,CAAC,OAc3C,CAAC;AAEH,MAAM,WAAW,sBAAsB;IACrC,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AACD,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AAEtF,OAAO,EACL,8BAA8B,EAC9B,+BAA+B,EAC/B,gCAAgC,EAChC,+BAA+B,EAC/B,8BAA8B,EAC9B,+BAA+B,EAC/B,iCAAiC,EACjC,iCAAiC,EACjC,kCAAkC,EAClC,oCAAoC,EACpC,gCAAgC,EAChC,oCAAoC,EACpC,sCAAsC,EACtC,qCAAqC,GACtC,CAAC"}

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

@@ -0,0 +1,81 @@
+import { z } from 'zod/v4';
+/**
+ * `ALL` — matches every metric folder name.
+ */
+declare const FolderNameAllSpecifierSchema: z.ZodObject<{
+    op: z.ZodLiteral<"ALL">;
+}, z.core.$loose>;
+/**
+ * `NONE` — matches no metric folder name.
+ */
+declare const FolderNameNoneSpecifierSchema: z.ZodObject<{
+    op: z.ZodLiteral<"NONE">;
+}, z.core.$loose>;
+/**
+ * `AND` — logical conjunction of child folder-name specifiers.
+ * An empty `specifiers[]` is rejected by the server.
+ */
+declare const FolderNameAndSpecifierSchema: 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 folder-name specifiers.
+ * An empty `specifiers[]` is rejected by the server.
+ */
+declare const FolderNameOrSpecifierSchema: 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 child folder-name specifier.
+ */
+declare const FolderNameNotSpecifierSchema: z.ZodObject<{
+    op: z.ZodLiteral<"NOT">;
+    specifier: z.ZodLazy<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+}, z.core.$loose>;
+/**
+ * `EXACT` — matches folder names by exact string equality.
+ * `ignoreCase=true` enables case-insensitive matching.
+ */
+declare const FolderNameExactSpecifierSchema: z.ZodObject<{
+    op: z.ZodLiteral<"EXACT">;
+    names: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    ignoreCase: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+/**
+ * `REGEX` — matches folder names where the full name satisfies `pattern`
+ * (Java regex).
+ */
+declare const FolderNameRegExSpecifierSchema: z.ZodObject<{
+    op: z.ZodLiteral<"REGEX">;
+    pattern: z.ZodOptional<z.ZodString>;
+    ignoreCase: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+/**
+ * `CHILDREN` — matches folders that are direct children of `prefix`,
+ * or all descendants when `recursive=true`.
+ *
+ * Metric attribute names are typically stored in a virtual folder
+ * hierarchy using dots as separators. `prefix` can be a dot-delimited
+ * parent path (e.g. `"my.namespace"`).
+ */
+declare const FolderNameChildrenSpecifierSchema: z.ZodObject<{
+    op: z.ZodLiteral<"CHILDREN">;
+    prefix: z.ZodOptional<z.ZodString>;
+    recursive: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+/**
+ * Discriminated union of all `FolderNameSpecifier` variants.
+ *
+ * Used inside `AttributeNameFolderSpecifierSchema` to restrict which
+ * attribute-name folders are selected. Folders correspond to the virtual
+ * namespace hierarchy of metric attribute names.
+ */
+export declare const FolderNameSpecifierSchema: z.ZodType;
+export interface FolderNameSpecifier {
+    op: string;
+    [key: string]: unknown;
+}
+export { FolderNameAllSpecifierSchema, FolderNameNoneSpecifierSchema, FolderNameAndSpecifierSchema, FolderNameOrSpecifierSchema, FolderNameNotSpecifierSchema, FolderNameExactSpecifierSchema, FolderNameRegExSpecifierSchema, FolderNameChildrenSpecifierSchema, };
+//# sourceMappingURL=folder-name-specifier.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"folder-name-specifier.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/model/datastore/metrics-metadata/folder-name-specifier.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAE3B;;GAEG;AACH,QAAA,MAAM,4BAA4B;;iBAEhC,CAAC;AAEH;;GAEG;AACH,QAAA,MAAM,6BAA6B;;iBAEjC,CAAC;AAEH;;;GAGG;AACH,QAAA,MAAM,4BAA4B;;;iBAOhC,CAAC;AAEH;;;GAGG;AACH,QAAA,MAAM,2BAA2B;;;iBAO/B,CAAC;AAEH;;GAEG;AACH,QAAA,MAAM,4BAA4B;;;iBAGhC,CAAC;AAEH;;;GAGG;AACH,QAAA,MAAM,8BAA8B;;;;iBAIlC,CAAC;AAEH;;;GAGG;AACH,QAAA,MAAM,8BAA8B;;;;iBAIlC,CAAC;AAEH;;;;;;;GAOG;AACH,QAAA,MAAM,iCAAiC;;;;iBAIrC,CAAC;AAEH;;;;;;GAMG;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,iCAAiC,GAClC,CAAC"}

package/dist/src/lib/model/datastore/metrics-metadata/index.d.ts

@@ -0,0 +1,7 @@
+export * from './source-name-specifier';
+export * from './folder-name-specifier';
+export * from './attribute-name-specifier';
+export * from './query-specifier';
+export * from './query';
+export * from './response';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/lib/model/datastore/metrics-metadata/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/model/datastore/metrics-metadata/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,mBAAmB,CAAC;AAClC,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC"}

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

@@ -0,0 +1,160 @@
+import { z } from 'zod/v4';
+/**
+ * Identifies a Management Module by `name`. Used inside `GROUP` to
+ * constrain metric selection to a specific management module's group.
+ */
+declare const ManagementModuleIdSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+/**
+ * `ALL` — selects all metrics (and optionally all folders).
+ * The broadest specifier; typically used as the starting point and
+ * narrowed with `AND`/`NOT` combinators.
+ */
+declare const QueryAllSpecifierSchema: z.ZodObject<{
+    op: z.ZodLiteral<"ALL">;
+    includeFolders: z.ZodOptional<z.ZodBoolean>;
+    includeMetrics: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+/**
+ * `NONE` — selects no metrics. Useful as a no-op placeholder when a
+ * specifier is structurally required but no metrics should match.
+ */
+declare const QueryNoneSpecifierSchema: z.ZodObject<{
+    op: z.ZodLiteral<"NONE">;
+}, z.core.$loose>;
+/**
+ * `AND` — logical conjunction of child specifiers. Only metrics matched
+ * by ALL children are included. An empty `specifiers[]` is rejected.
+ */
+declare const QueryAndSpecifierSchema: 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 specifiers. Metrics matched by
+ * ANY child are included. An empty `specifiers[]` is rejected.
+ */
+declare const QueryOrSpecifierSchema: 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 child specifier. Metrics that do NOT
+ * match the child are included.
+ */
+declare const QueryNotSpecifierSchema: z.ZodObject<{
+    op: z.ZodLiteral<"NOT">;
+    specifier: z.ZodLazy<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+}, z.core.$loose>;
+/**
+ * `SPEC` — the primary composite filter. Selects metrics that match ALL
+ * of the provided sub-specifiers:
+ * - `sourceNameSpecifier` — filters by metric source name
+ * - `folderNameSpecifier` — filters by attribute folder hierarchy
+ * - `attributeNameSpecifier` — filters by attribute name within folders
+ *
+ * Omitting a sub-specifier means "match all" for that dimension.
+ *
+ * @example Select metrics from sources matching "foo.*" that have a "health" attribute
+ * ```json
+ * {
+ *   "op": "SPEC",
+ *   "sourceNameSpecifier": { "op": "REGEX", "pattern": "foo\\..*" },
+ *   "attributeNameSpecifier": { "op": "EXACT", "names": ["health"] }
+ * }
+ * ```
+ */
+declare const QuerySpecSpecifierSchema: z.ZodObject<{
+    op: z.ZodLiteral<"SPEC">;
+    sourceNameSpecifier: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+    folderNameSpecifier: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+    attributeNameSpecifier: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+}, z.core.$loose>;
+/**
+ * `ID` — selects metrics by their exact metric ID strings. The `ids`
+ * array must be non-empty (server returns 400 if missing or empty).
+ *
+ * Metric IDs are the opaque unique identifiers returned in `metric.id`
+ * columns; use `FROM_METADATA` + `DESCRIBE` to discover them.
+ */
+declare const QueryIdSpecifierSchema: z.ZodObject<{
+    op: z.ZodLiteral<"ID">;
+    ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
+/**
+ * `ATTRIBUTE` — selects metrics that match one or more
+ * `QueryAttributeExpression`s (attribute name + value + operator).
+ * All expressions are implicitly AND-ed.
+ *
+ * This is the top-level metric attribute filter. To filter attribute
+ * *names* (i.e. which attributes to return per metric), use the
+ * `SPEC` specifier's `attributeNameSpecifier` instead.
+ */
+declare const QueryAttributeSpecifierSchema: z.ZodObject<{
+    op: z.ZodLiteral<"ATTRIBUTE">;
+    expressions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        values: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        operator: z.ZodOptional<z.ZodEnum<{
+            IN: "IN";
+            NOT_IN: "NOT_IN";
+            MATCHES: "MATCHES";
+            NOT_MATCHES: "NOT_MATCHES";
+            GE: "GE";
+            GT: "GT";
+            LE: "LE";
+            LT: "LT";
+        }>>;
+        comparator: z.ZodOptional<z.ZodEnum<{
+            LEXICAL: "LEXICAL";
+            NUMBER: "NUMBER";
+            DATETIME: "DATETIME";
+        }>>;
+        caseInsensitive: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+/**
+ * `GROUP` — selects all metrics belonging to a specific metric group
+ * within a management module. `id` is the group identifier;
+ * `managementModuleId` narrows to a specific module.
+ *
+ * Management modules organize metrics into administrative groups.
+ * Rare in hand-authored queries — most use `SPEC` or `ATTRIBUTE`.
+ */
+declare const QueryMetricGroupSpecifierSchema: z.ZodObject<{
+    op: z.ZodLiteral<"GROUP">;
+    id: z.ZodOptional<z.ZodString>;
+    managementModuleId: z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+/**
+ * `SERVICE` — selects metrics associated with specific service names.
+ * `values` is a list of service name strings; metrics linked to any of
+ * the listed services are included.
+ */
+declare const ServiceFilterSpecifierSchema: z.ZodObject<{
+    op: z.ZodLiteral<"SERVICE">;
+    values: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
+/**
+ * Top-level `QuerySpecifier` — discriminated union of all Metrics Metadata
+ * specifier types. Sent as the `specifier` field of `MetadataMetricQuery`.
+ *
+ * The tree is composed of boolean combinators (`AND`, `OR`, `NOT`) and
+ * leaf specifiers (`ALL`, `NONE`, `SPEC`, `ID`, `ATTRIBUTE`, `GROUP`,
+ * `SERVICE`).
+ *
+ * Start with `SPEC` for the most common use case (filter by source name
+ * and/or attribute name). Use `ID` for precise lookup by known metric IDs.
+ * Combine with `AND`/`OR`/`NOT` for complex multi-criteria filters.
+ */
+export declare const QuerySpecifierSchema: z.ZodType;
+export interface QuerySpecifier {
+    op: string;
+    [key: string]: unknown;
+}
+export type ManagementModuleId = z.infer<typeof ManagementModuleIdSchema>;
+export { ManagementModuleIdSchema, QueryAllSpecifierSchema, QueryNoneSpecifierSchema, QueryAndSpecifierSchema, QueryOrSpecifierSchema, QueryNotSpecifierSchema, QuerySpecSpecifierSchema, QueryIdSpecifierSchema, QueryAttributeSpecifierSchema, QueryMetricGroupSpecifierSchema, ServiceFilterSpecifierSchema, };
+//# sourceMappingURL=query-specifier.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"query-specifier.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/model/datastore/metrics-metadata/query-specifier.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAQ3B;;;GAGG;AACH,QAAA,MAAM,wBAAwB;;iBAE5B,CAAC;AAEH;;;;GAIG;AACH,QAAA,MAAM,uBAAuB;;;;iBAI3B,CAAC;AAEH;;;GAGG;AACH,QAAA,MAAM,wBAAwB;;iBAE5B,CAAC;AAEH;;;GAGG;AACH,QAAA,MAAM,uBAAuB;;;iBAO3B,CAAC;AAEH;;;GAGG;AACH,QAAA,MAAM,sBAAsB;;;iBAO1B,CAAC;AAEH;;;GAGG;AACH,QAAA,MAAM,uBAAuB;;;iBAG3B,CAAC;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,QAAA,MAAM,wBAAwB;;;;;iBAW5B,CAAC;AAEH;;;;;;GAMG;AACH,QAAA,MAAM,sBAAsB;;;iBAQ1B,CAAC;AAEH;;;;;;;;GAQG;AACH,QAAA,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;iBAMjC,CAAC;AAEH;;;;;;;GAOG;AACH,QAAA,MAAM,+BAA+B;;;;;;iBAMnC,CAAC;AAEH;;;;GAIG;AACH,QAAA,MAAM,4BAA4B;;;iBAGhC,CAAC;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,oBAAoB,EAAE,CAAC,CAAC,OAWnC,CAAC;AAEH,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AACD,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,OAAO,EACL,wBAAwB,EACxB,uBAAuB,EACvB,wBAAwB,EACxB,uBAAuB,EACvB,sBAAsB,EACtB,uBAAuB,EACvB,wBAAwB,EACxB,sBAAsB,EACtB,6BAA6B,EAC7B,+BAA+B,EAC/B,4BAA4B,GAC7B,CAAC"}

package/dist/src/lib/model/datastore/metrics-metadata/query.d.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod/v4';
+/**
+ * Server-side hint for Metrics Metadata queries.
+ * `ForceRange` forces the server to apply a time-range filter even when
+ * no `queryRange` is explicitly provided (uses the default range).
+ */
+declare const QueryHintForceRangeSchema: z.ZodObject<{
+    hint: z.ZodLiteral<"ForceRange">;
+}, z.core.$loose>;
+export declare const QueryHintSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    hint: z.ZodLiteral<"ForceRange">;
+}, z.core.$loose>], "hint">;
+/**
+ * Top-level Metrics Metadata query envelope sent to `/metadata/queryMetric`.
+ *
+ * Returns an array of `MetricDescriptor` objects matching `specifier`.
+ * Each descriptor carries the metric's source, path, name, description,
+ * type, and attribute map.
+ *
+ * **Important — `clamp`**: when omitted, the server returns ALL matching
+ * metrics. On large tenants this is multiple MB / tens of thousands of
+ * descriptors per call. New queries should default `clamp: 500` and raise
+ * only when needed. The UI editor applies this default automatically
+ * for new MM queries; agent-generated queries should do the same.
+ *
+ * @example Minimal usage — first 100 metrics from a source regex
+ * ```json
+ * {
+ *   "specifier": { "op": "SPEC", "sourceNameSpecifier": { "op": "REGEX", "pattern": "foo\\..*" } },
+ *   "clamp": 100
+ * }
+ * ```
+ */
+export declare const MetadataMetricQuerySchema: z.ZodObject<{
+    specifier: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+    clamp: z.ZodOptional<z.ZodNumber>;
+    time: z.ZodOptional<z.ZodNumber>;
+    range: z.ZodOptional<z.ZodNumber>;
+    includeLive: z.ZodOptional<z.ZodBoolean>;
+    authorizationView: z.ZodOptional<z.ZodString>;
+    includeProfile: z.ZodOptional<z.ZodBoolean>;
+    profileLevel: z.ZodOptional<z.ZodString>;
+    queryHints: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        hint: z.ZodLiteral<"ForceRange">;
+    }, z.core.$loose>], "hint">>>;
+}, z.core.$loose>;
+export type QueryHint = z.infer<typeof QueryHintSchema>;
+export type MetadataMetricQuery = z.infer<typeof MetadataMetricQuerySchema>;
+export { QueryHintForceRangeSchema };
+//# sourceMappingURL=query.d.ts.map

package/dist/src/lib/model/datastore/metrics-metadata/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/model/datastore/metrics-metadata/query.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAG3B;;;;GAIG;AACH,QAAA,MAAM,yBAAyB;;iBAE7B,CAAC;AAEH,eAAO,MAAM,eAAe;;2BAEoD,CAAC;AAEjF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;iBAoCpC,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,OAAO,EAAE,yBAAyB,EAAE,CAAC"}

package/dist/src/lib/model/datastore/metrics-metadata/response.d.ts

@@ -0,0 +1,44 @@
+import { z } from 'zod/v4';
+export declare const MetricAttributeSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    sourceName: z.ZodOptional<z.ZodString>;
+    type: z.ZodNumber;
+    attributeName: z.ZodOptional<z.ZodString>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    firstSeen: z.ZodOptional<z.ZodNumber>;
+    lastSeen: z.ZodOptional<z.ZodNumber>;
+    live: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+export declare const MetricFolderSchema: z.ZodObject<{
+    sourceId: z.ZodOptional<z.ZodString>;
+    sourceName: z.ZodOptional<z.ZodString>;
+    folderName: z.ZodOptional<z.ZodString>;
+    firstSeen: z.ZodOptional<z.ZodNumber>;
+    lastSeen: z.ZodOptional<z.ZodNumber>;
+    live: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+export declare const MetadataMetricQueryResponseV2Schema: z.ZodObject<{
+    metrics: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        sourceName: z.ZodOptional<z.ZodString>;
+        type: z.ZodNumber;
+        attributeName: z.ZodOptional<z.ZodString>;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        firstSeen: z.ZodOptional<z.ZodNumber>;
+        lastSeen: z.ZodOptional<z.ZodNumber>;
+        live: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>>;
+    folders: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        sourceId: z.ZodOptional<z.ZodString>;
+        sourceName: z.ZodOptional<z.ZodString>;
+        folderName: z.ZodOptional<z.ZodString>;
+        firstSeen: z.ZodOptional<z.ZodNumber>;
+        lastSeen: z.ZodOptional<z.ZodNumber>;
+        live: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>>;
+    analytics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$loose>;
+export type MetricAttribute = z.infer<typeof MetricAttributeSchema>;
+export type MetricFolder = z.infer<typeof MetricFolderSchema>;
+export type MetadataMetricQueryResponseV2 = z.infer<typeof MetadataMetricQueryResponseV2Schema>;
+//# sourceMappingURL=response.d.ts.map

package/dist/src/lib/model/datastore/metrics-metadata/response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/model/datastore/metrics-metadata/response.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAE3B,eAAO,MAAM,qBAAqB;;;;;;;;;iBAShC,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;iBAO7B,CAAC;AAEH,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;iBAI9C,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAC"}