@dx-do/client 7.12.2 → 7.14.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +1 -1
- package/dist/index.cjs.js +3249 -507
- package/dist/index.cjs.js.map +1 -1
- package/dist/index.esm.js +3211 -508
- package/dist/index.esm.js.map +1 -1
- package/dist/src/index.d.ts +10 -0
- package/dist/src/index.d.ts.map +1 -1
- package/dist/src/lib/model/datastore/nassql/operations.d.ts +8 -1
- package/dist/src/lib/model/datastore/nassql/operations.d.ts.map +1 -1
- package/dist/src/lib/model/datastore/nassql/query.d.ts +8 -1
- package/dist/src/lib/model/datastore/nassql/query.d.ts.map +1 -1
- package/dist/src/lib/model/datastore/nassql/response.d.ts +11 -0
- package/dist/src/lib/model/datastore/nassql/response.d.ts.map +1 -1
- package/dist/src/lib/model/datastore/states/filters.d.ts +1 -1
- package/dist/src/lib/model/datastore/states/filters.d.ts.map +1 -1
- package/dist/src/lib/model/datastore/tas/filters.d.ts +3 -1
- package/dist/src/lib/model/datastore/tas/filters.d.ts.map +1 -1
- package/dist/src/lib/model/datastore/tas/query.d.ts +2 -1
- package/dist/src/lib/model/datastore/tas/query.d.ts.map +1 -1
- package/dist/src/lib/model/datastore/tas/response.d.ts +17 -16
- package/dist/src/lib/model/datastore/tas/response.d.ts.map +1 -1
- package/dist/src/lib/model/datastore/tas/store.d.ts +3 -3
- package/dist/src/lib/model/inventory/topology-rules/jexl/java-regex.d.ts +0 -14
- package/dist/src/lib/model/inventory/topology-rules/jexl/java-regex.d.ts.map +1 -1
- package/dist/src/lib/model/inventory/topology-rules/jexl-context.d.ts +34 -0
- package/dist/src/lib/model/inventory/topology-rules/jexl-context.d.ts.map +1 -0
- package/dist/src/lib/model/inventory/topology-rules/mm-translate.d.ts +5 -1
- package/dist/src/lib/model/inventory/topology-rules/mm-translate.d.ts.map +1 -1
- package/dist/src/lib/model/inventory/topology-rules/projection.d.ts +50 -3
- package/dist/src/lib/model/inventory/topology-rules/projection.d.ts.map +1 -1
- package/dist/src/lib/model/inventory/topology-rules/rule.d.ts +1 -1
- package/dist/src/lib/model/inventory/topology-rules/sourcename-dialect.d.ts +82 -0
- package/dist/src/lib/model/inventory/topology-rules/sourcename-dialect.d.ts.map +1 -0
- package/dist/src/lib/model/inventory/topology-rules/sourcename-dialect.fixtures.d.ts +25 -0
- package/dist/src/lib/model/inventory/topology-rules/sourcename-dialect.fixtures.d.ts.map +1 -0
- package/dist/src/lib/model/inventory/topology-rules/sourcename-lint.d.ts +25 -0
- package/dist/src/lib/model/inventory/topology-rules/sourcename-lint.d.ts.map +1 -0
- package/dist/src/lib/model/metric-anomaly/group.d.ts +88 -0
- package/dist/src/lib/model/metric-anomaly/group.d.ts.map +1 -0
- package/dist/src/lib/model/metric-anomaly/metrics-preview.d.ts +74 -0
- package/dist/src/lib/model/metric-anomaly/metrics-preview.d.ts.map +1 -0
- package/dist/src/lib/model/metric-anomaly/save.d.ts +63 -0
- package/dist/src/lib/model/metric-anomaly/save.d.ts.map +1 -0
- package/dist/src/lib/model/metric-anomaly/search.d.ts +63 -0
- package/dist/src/lib/model/metric-anomaly/search.d.ts.map +1 -0
- package/dist/src/lib/model/metricconfig/filter.d.ts +60 -0
- package/dist/src/lib/model/metricconfig/filter.d.ts.map +1 -0
- package/dist/src/lib/model/sli/group.d.ts +3 -2
- package/dist/src/lib/model/sli/group.d.ts.map +1 -1
- package/dist/src/lib/model/sli/metrics-preview.d.ts +8 -0
- package/dist/src/lib/model/sli/metrics-preview.d.ts.map +1 -1
- package/dist/src/lib/services/dx-saas.service.d.ts +2 -2
- package/dist/src/lib/services/metric-anomaly.service.d.ts +83 -0
- package/dist/src/lib/services/metric-anomaly.service.d.ts.map +1 -0
- package/dist/src/lib/services/service-monolith.d.ts +2 -0
- package/dist/src/lib/services/service-monolith.d.ts.map +1 -1
- package/package.json +2 -1
|
@@ -0,0 +1,82 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* The Topology Creator `sourceName` matching dialect — the engine the local
|
|
3
|
+
* simulation uses and the catalog every help surface is rendered from.
|
|
4
|
+
*
|
|
5
|
+
* Measured on DXO2 26.8.2 (two tenants, 2026-09-01/04; a 23-case battery and a
|
|
6
|
+
* 22-rule construct matrix, 22/22 agreement in preview AND materialised
|
|
7
|
+
* vertices). The server compiles `java.util.regex` with CASE_INSENSITIVE and
|
|
8
|
+
* matches with `matches()` (full string) — but only after a preprocessor that:
|
|
9
|
+
*
|
|
10
|
+
* 1. escapes every `|` outside a parenthesised group that contains a `|`
|
|
11
|
+
* (so the segment separator is literal and a user-written `\|` becomes a
|
|
12
|
+
* literal backslash followed by REAL alternation);
|
|
13
|
+
* 2. keeps `( … | … )` groups as real alternation, escapes every other
|
|
14
|
+
* parenthesis (so `Tomcat (Prod)` matches literally);
|
|
15
|
+
* 3. escapes `+ ? { }` everywhere, pipe groups included;
|
|
16
|
+
* 4. drops a `*` that does not follow a `.`;
|
|
17
|
+
* 5. refuses wildcard-only patterns (`.*`, `^.*$`) — they match nothing.
|
|
18
|
+
*
|
|
19
|
+
* An unparseable result matches nothing (the API answers HTTP 200 with an
|
|
20
|
+
* empty preview). This module reproduces exactly that; `[\pL]` (a Unicode
|
|
21
|
+
* property inside a class) is the one construct the server honours that the
|
|
22
|
+
* JavaScript engine here cannot, so it degrades to "no match" locally.
|
|
23
|
+
*/
|
|
24
|
+
/** Parenthesised regions that contain a `|` — the only place alternation is honoured. */
|
|
25
|
+
export declare function pipeGroupRanges(pattern: string): Array<[number, number]>;
|
|
26
|
+
/** `.*`, `^.*$`, `.*.*`, `` — patterns the server refuses as catch-alls. */
|
|
27
|
+
export declare function isWildcardOnlySourceName(pattern: string): boolean;
|
|
28
|
+
/** The Topology Creator preprocessor: rule pattern → the Java regex the server compiles. */
|
|
29
|
+
export declare function tcSourceNameToJavaRegex(pattern: string): string;
|
|
30
|
+
export type TcSourceNameCompilation = {
|
|
31
|
+
ok: true;
|
|
32
|
+
regex: RegExp;
|
|
33
|
+
} | {
|
|
34
|
+
ok: false;
|
|
35
|
+
reason: 'wildcard-only' | 'invalid';
|
|
36
|
+
message: string;
|
|
37
|
+
};
|
|
38
|
+
/** Compiles a rule pattern the way the server would. Never throws. */
|
|
39
|
+
export declare function compileTcSourceName(pattern: string): TcSourceNameCompilation;
|
|
40
|
+
/** Whether the Topology Creator would match `sourceName` against a rule's pattern. */
|
|
41
|
+
export declare function tcSourceNameMatches(sourceName: string, pattern: string): boolean;
|
|
42
|
+
/**
|
|
43
|
+
* The Metrics-Metadata REGEX-specifier pattern that selects the same sources.
|
|
44
|
+
* MM REGEX is a strict Java full match; the preprocessed pattern is already a
|
|
45
|
+
* valid Java regex (literal pipes and parentheses arrive escaped). Pair it
|
|
46
|
+
* with `ignoreCase: true` — the Topology Creator matches case-insensitively.
|
|
47
|
+
*/
|
|
48
|
+
export declare function tcSourceNameToMmPattern(pattern: string): string;
|
|
49
|
+
export type SourceNameDialectRuleId = 'escaped-pipe' | 'top-level-alternation' | 'pipe-group' | 'literal-parens' | 'escaped-paren' | 'parens-pipe-trap' | 'quantifier-literal' | 'bare-star' | 'case-insensitive' | 'wildcard-only' | 'bare-substring' | 'quoted-literal' | 'unicode-property' | 'nested-brackets' | 'unbalanced' | 'parent-folder-required' | 'parent-folder-prefix' | 'parent-folder-dot' | 'attribute-name-ignored' | 'attribute-filters-relative' | 'external-id-format' | 'custom-attribute-standard-name' | 'custom-attribute-reserved-name' | 'nest-levels' | 'vertex-name-index';
|
|
50
|
+
export interface SourceNameDialectRule {
|
|
51
|
+
id: SourceNameDialectRuleId;
|
|
52
|
+
appliesTo: 'sourceName' | 'attributeParentFolder' | 'attributeName' | 'filters' | 'externalIdFormat' | 'customAttributes' | 'nest_levels' | 'vertexNameIndex';
|
|
53
|
+
/** A short name for the trap — the row heading in the ui help panel (plain text). */
|
|
54
|
+
title?: string;
|
|
55
|
+
/** What an author types — a pattern or field value, rendered as code. */
|
|
56
|
+
youMightWrite: string;
|
|
57
|
+
/** Why they typed it, when the value alone does not say (prose). */
|
|
58
|
+
intent?: string;
|
|
59
|
+
/** What the server does with it (markdown prose; code in backticks). */
|
|
60
|
+
whatHappens: string;
|
|
61
|
+
/** The corrected pattern or value, rendered as code — when there is one. */
|
|
62
|
+
writeInstead?: string;
|
|
63
|
+
/** Source names `writeInstead` matches. Self-checking, like `example`. */
|
|
64
|
+
fixMatches?: readonly string[];
|
|
65
|
+
/** Guidance when the fix is not a single pattern (markdown prose). */
|
|
66
|
+
advice?: string;
|
|
67
|
+
/** Self-checking: `tcSourceNameMatches(example.sourceName, example.pattern) === example.matches`. */
|
|
68
|
+
example?: {
|
|
69
|
+
pattern: string;
|
|
70
|
+
sourceName: string;
|
|
71
|
+
matches: boolean;
|
|
72
|
+
};
|
|
73
|
+
}
|
|
74
|
+
/**
|
|
75
|
+
* "What you might write → what actually happens → write this instead", one
|
|
76
|
+
* row per trap. Rendered into the inventorize cookbook (and so into
|
|
77
|
+
* `dx-do help inventorize` and the ui help panel) by the agentic-gen
|
|
78
|
+
* generator; the linter's hints cite these ids. Keep the prose
|
|
79
|
+
* tenant-neutral — it ships in the published corpus.
|
|
80
|
+
*/
|
|
81
|
+
export declare const SOURCENAME_DIALECT_CATALOG: readonly SourceNameDialectRule[];
|
|
82
|
+
//# sourceMappingURL=sourcename-dialect.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"sourcename-dialect.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/model/inventory/topology-rules/sourcename-dialect.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,yFAAyF;AACzF,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAWxE;AAED,4EAA4E;AAC5E,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEjE;AAED,4FAA4F;AAC5F,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAY/D;AAED,MAAM,MAAM,uBAAuB,GAC/B;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC3B;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,eAAe,GAAG,SAAS,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAExE,sEAAsE;AACtE,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,uBAAuB,CAkB5E;AAED,sFAAsF;AACtF,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAGhF;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE/D;AAED,MAAM,MAAM,uBAAuB,GAC/B,cAAc,GACd,uBAAuB,GACvB,YAAY,GACZ,gBAAgB,GAChB,eAAe,GACf,kBAAkB,GAClB,oBAAoB,GACpB,WAAW,GACX,kBAAkB,GAClB,eAAe,GACf,gBAAgB,GAChB,gBAAgB,GAChB,kBAAkB,GAClB,iBAAiB,GACjB,YAAY,GACZ,wBAAwB,GACxB,sBAAsB,GACtB,mBAAmB,GACnB,wBAAwB,GACxB,4BAA4B,GAC5B,oBAAoB,GACpB,gCAAgC,GAChC,gCAAgC,GAChC,aAAa,GACb,mBAAmB,CAAC;AAGxB,MAAM,WAAW,qBAAqB;IACpC,EAAE,EAAE,uBAAuB,CAAC;IAC5B,SAAS,EACL,YAAY,GACZ,uBAAuB,GACvB,eAAe,GACf,SAAS,GACT,kBAAkB,GAClB,kBAAkB,GAClB,aAAa,GACb,iBAAiB,CAAC;IACtB,qFAAqF;IACrF,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,yEAAyE;IACzE,aAAa,EAAE,MAAM,CAAC;IACtB,oEAAoE;IACpE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,wEAAwE;IACxE,WAAW,EAAE,MAAM,CAAC;IACpB,4EAA4E;IAC5E,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,0EAA0E;IAC1E,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,sEAAsE;IACtE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qGAAqG;IACrG,OAAO,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;CACrE;AAED;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,EAAE,SAAS,qBAAqB,EA4UtE,CAAC"}
|
|
@@ -0,0 +1,25 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* The sourceName calibration corpus: the 23-case battery (five sources) and
|
|
3
|
+
* the 22-rule construct matrix (twelve sources) measured against DXO2 26.8.2
|
|
4
|
+
* on two tenants (2026-09-01/04). `expected` lists the source ids the SERVER
|
|
5
|
+
* matched. The offline test checks the local engine against these; the live
|
|
6
|
+
* suite and the matrix driver re-measure the server against them. `token`
|
|
7
|
+
* makes source names run-unique — a metric identity that aged out cannot be
|
|
8
|
+
* registered again, so a live run always mints a fresh token.
|
|
9
|
+
*/
|
|
10
|
+
export interface SourceNameFixtureCase {
|
|
11
|
+
id: string;
|
|
12
|
+
construct: string;
|
|
13
|
+
sourceName: string;
|
|
14
|
+
/** Source ids the server matched, in source declaration order. */
|
|
15
|
+
expected: string[];
|
|
16
|
+
}
|
|
17
|
+
export interface SourceNameFixture<K extends string> {
|
|
18
|
+
sources: Record<K, string>;
|
|
19
|
+
cases: SourceNameFixtureCase[];
|
|
20
|
+
}
|
|
21
|
+
export type BatterySourceId = 'a' | 'b' | 'c' | 'd' | 'e';
|
|
22
|
+
export declare function sourceNameBattery(token: string): SourceNameFixture<BatterySourceId>;
|
|
23
|
+
export type MatrixSourceId = 'web01' | 'web02' | 'web10' | 'web1' | 'WEB03' | 'db1' | 'db22' | 'app' | 'app-prod' | 'cache-a' | 'cache-aa' | 'cache-aaa';
|
|
24
|
+
export declare function sourceNameMatrix(token: string): SourceNameFixture<MatrixSourceId>;
|
|
25
|
+
//# sourceMappingURL=sourcename-dialect.fixtures.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"sourcename-dialect.fixtures.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/model/inventory/topology-rules/sourcename-dialect.fixtures.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,WAAW,qBAAqB;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,kEAAkE;IAClE,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,MAAM,WAAW,iBAAiB,CAAC,CAAC,SAAS,MAAM;IACjD,OAAO,EAAE,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;IAC3B,KAAK,EAAE,qBAAqB,EAAE,CAAC;CAChC;AAED,MAAM,MAAM,eAAe,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AAI1D,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,iBAAiB,CAAC,eAAe,CAAC,CAsFnF;AAED,MAAM,MAAM,cAAc,GACtB,OAAO,GACP,OAAO,GACP,OAAO,GACP,MAAM,GACN,OAAO,GACP,KAAK,GACL,MAAM,GACN,KAAK,GACL,UAAU,GACV,SAAS,GACT,UAAU,GACV,WAAW,CAAC;AAEhB,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,iBAAiB,CAAC,cAAc,CAAC,CA0HjF"}
|
|
@@ -0,0 +1,25 @@
|
|
|
1
|
+
import { SourceNameDialectRuleId } from './sourcename-dialect';
|
|
2
|
+
/**
|
|
3
|
+
* Flags the Topology Creator dialect traps in a `sourceName` pattern — the
|
|
4
|
+
* hints the ui shows under the field, the CLI prints on a dry run, and the
|
|
5
|
+
* MCP simulate tool returns. Deterministic, never throws.
|
|
6
|
+
*
|
|
7
|
+
* Severity: `error` = the rule matches nothing (or something other than
|
|
8
|
+
* what was written); `warning` = a construct that almost certainly does not
|
|
9
|
+
* do what it looks like; `info` = dialect behaviour worth knowing.
|
|
10
|
+
*/
|
|
11
|
+
export type SourceNameHintSeverity = 'error' | 'warning' | 'info';
|
|
12
|
+
export interface SourceNameHint {
|
|
13
|
+
ruleId: SourceNameDialectRuleId;
|
|
14
|
+
severity: SourceNameHintSeverity;
|
|
15
|
+
message: string;
|
|
16
|
+
/** First offending range in the pattern, [start, end). */
|
|
17
|
+
span?: {
|
|
18
|
+
start: number;
|
|
19
|
+
end: number;
|
|
20
|
+
};
|
|
21
|
+
/** A rewritten pattern, when the fix is mechanical. */
|
|
22
|
+
suggestion?: string;
|
|
23
|
+
}
|
|
24
|
+
export declare function lintSourceName(pattern: string): SourceNameHint[];
|
|
25
|
+
//# sourceMappingURL=sourcename-lint.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"sourcename-lint.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/model/inventory/topology-rules/sourcename-lint.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,uBAAuB,EACxB,MAAM,sBAAsB,CAAC;AAE9B;;;;;;;;GAQG;AAEH,MAAM,MAAM,sBAAsB,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;AAElE,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,uBAAuB,CAAC;IAChC,QAAQ,EAAE,sBAAsB,CAAC;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,0DAA0D;IAC1D,IAAI,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;IACtC,uDAAuD;IACvD,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAgGD,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,EAAE,CAqKhE"}
|
|
@@ -0,0 +1,88 @@
|
|
|
1
|
+
import { z } from 'zod/v4';
|
|
2
|
+
/**
|
|
3
|
+
* The metric product an anomaly-detection group is scoped to. Matching,
|
|
4
|
+
* the filter-field catalog and the default groups are all per product.
|
|
5
|
+
* Short CLI-friendly aliases map to the wire names the server stores.
|
|
6
|
+
*/
|
|
7
|
+
export declare const ANOMALY_DETECTION_PRODUCTS: {
|
|
8
|
+
readonly apm: "Application Performance Management";
|
|
9
|
+
readonly capm: "CAPM";
|
|
10
|
+
readonly uim: "UIM";
|
|
11
|
+
readonly custom: "CUSTOM";
|
|
12
|
+
};
|
|
13
|
+
export type AnomalyDetectionProductAlias = keyof typeof ANOMALY_DETECTION_PRODUCTS;
|
|
14
|
+
/**
|
|
15
|
+
* Resolves a product alias (`apm`) or wire name (`Application Performance
|
|
16
|
+
* Management`), case-insensitively, to the wire name; undefined when unknown.
|
|
17
|
+
*/
|
|
18
|
+
export declare function resolveAnomalyDetectionProduct(input: string): string | undefined;
|
|
19
|
+
/**
|
|
20
|
+
* The alerting half of an anomaly-detection group. `enabled` is the on/off
|
|
21
|
+
* switch for anomaly detection on the group's metrics; with
|
|
22
|
+
* `useSystemSettings: true` the remaining knobs come from the tenant default
|
|
23
|
+
* (`GET oi/v2/metricconfig/defaultalert`) and are stored as nulls.
|
|
24
|
+
*/
|
|
25
|
+
export declare const AnomalyAlertConfigSchema: z.ZodObject<{
|
|
26
|
+
enabled: z.ZodBoolean;
|
|
27
|
+
useSystemSettings: z.ZodOptional<z.ZodBoolean>;
|
|
28
|
+
timeOverThreshold: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
|
|
29
|
+
unit: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
30
|
+
observationTime: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
|
|
31
|
+
countOverThreshold: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
|
|
32
|
+
observationCount: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
|
|
33
|
+
deviationPercentage: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
|
|
34
|
+
deviationValue: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
|
|
35
|
+
deviationValueOp: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
36
|
+
threshold: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
|
|
37
|
+
alarmSeverity: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
38
|
+
alarmMessage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
39
|
+
policyId: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
|
|
40
|
+
acType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
41
|
+
}, z.core.$loose>;
|
|
42
|
+
export type AnomalyAlertConfig = z.infer<typeof AnomalyAlertConfigSchema>;
|
|
43
|
+
/**
|
|
44
|
+
* A metric anomaly-detection group (DXO2 Settings → Anomaly Detection
|
|
45
|
+
* Groups): a product-scoped filter selecting metrics plus the anomaly alert
|
|
46
|
+
* config. Same OI metricconfig `groups` family as SLI groups, but with no
|
|
47
|
+
* `type` — as returned by `groups/search` (`metricGroups[]`) and
|
|
48
|
+
* `groups?groupId=<id>`.
|
|
49
|
+
*/
|
|
50
|
+
export declare const AnomalyDetectionGroupSchema: z.ZodObject<{
|
|
51
|
+
groupName: z.ZodString;
|
|
52
|
+
groupId: z.ZodNumber;
|
|
53
|
+
filters: z.ZodArray<z.ZodObject<{
|
|
54
|
+
fieldDescription: z.ZodString;
|
|
55
|
+
field: z.ZodString;
|
|
56
|
+
value: z.ZodString;
|
|
57
|
+
condition: z.ZodString;
|
|
58
|
+
}, z.core.$loose>>;
|
|
59
|
+
description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
60
|
+
product: z.ZodString;
|
|
61
|
+
anomalyAlertConfig: z.ZodObject<{
|
|
62
|
+
enabled: z.ZodBoolean;
|
|
63
|
+
useSystemSettings: z.ZodOptional<z.ZodBoolean>;
|
|
64
|
+
timeOverThreshold: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
|
|
65
|
+
unit: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
66
|
+
observationTime: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
|
|
67
|
+
countOverThreshold: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
|
|
68
|
+
observationCount: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
|
|
69
|
+
deviationPercentage: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
|
|
70
|
+
deviationValue: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
|
|
71
|
+
deviationValueOp: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
72
|
+
threshold: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
|
|
73
|
+
alarmSeverity: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
74
|
+
alarmMessage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
75
|
+
policyId: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
|
|
76
|
+
acType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
77
|
+
}, z.core.$loose>;
|
|
78
|
+
defaultGroup: z.ZodOptional<z.ZodBoolean>;
|
|
79
|
+
serviceNames: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
|
|
80
|
+
creationTime: z.ZodOptional<z.ZodNumber>;
|
|
81
|
+
lastModifiedTime: z.ZodOptional<z.ZodNumber>;
|
|
82
|
+
createdBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
83
|
+
lastUpdatedBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
84
|
+
totalMetrics: z.ZodOptional<z.ZodNumber>;
|
|
85
|
+
breached: z.ZodOptional<z.ZodBoolean>;
|
|
86
|
+
}, z.core.$loose>;
|
|
87
|
+
export type AnomalyDetectionGroup = z.infer<typeof AnomalyDetectionGroupSchema>;
|
|
88
|
+
//# sourceMappingURL=group.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"group.d.ts","sourceRoot":"","sources":["../../../../../src/lib/model/metric-anomaly/group.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAI3B;;;;GAIG;AACH,eAAO,MAAM,0BAA0B;;;;;CAK7B,CAAC;AACX,MAAM,MAAM,4BAA4B,GAAG,MAAM,OAAO,0BAA0B,CAAC;AAEnF;;;GAGG;AACH,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAQhF;AAED;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;iBAqCnC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwBtC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC"}
|
|
@@ -0,0 +1,74 @@
|
|
|
1
|
+
import { z } from 'zod/v4';
|
|
2
|
+
import type { MetricConfigFilter } from '../metricconfig/filter';
|
|
3
|
+
/**
|
|
4
|
+
* Model for `POST oi/v2/metricconfig/groups/metrics` scoped by product — the
|
|
5
|
+
* live "matching metrics" preview the anomaly-detection group editor shows.
|
|
6
|
+
* Same endpoint as the SLI preview but keyed by `product` instead of
|
|
7
|
+
* `serviceNames`, with no `numericFilter`.
|
|
8
|
+
*/
|
|
9
|
+
export declare const AnomalyGroupMetricsRequestSchema: z.ZodObject<{
|
|
10
|
+
pageSize: z.ZodNumber;
|
|
11
|
+
product: z.ZodString;
|
|
12
|
+
customFilter: z.ZodObject<{
|
|
13
|
+
and: z.ZodObject<{
|
|
14
|
+
expressions: z.ZodArray<z.ZodObject<{
|
|
15
|
+
or: z.ZodObject<{
|
|
16
|
+
expressions: z.ZodArray<z.ZodObject<{
|
|
17
|
+
fieldDescription: z.ZodString;
|
|
18
|
+
field: z.ZodString;
|
|
19
|
+
value: z.ZodString;
|
|
20
|
+
condition: z.ZodString;
|
|
21
|
+
}, z.core.$loose>>;
|
|
22
|
+
}, z.core.$loose>;
|
|
23
|
+
}, z.core.$loose>>;
|
|
24
|
+
}, z.core.$loose>;
|
|
25
|
+
}, z.core.$loose>;
|
|
26
|
+
}, z.core.$loose>;
|
|
27
|
+
export type AnomalyGroupMetricsRequest = z.infer<typeof AnomalyGroupMetricsRequestSchema>;
|
|
28
|
+
export declare const AnomalyGroupMetricsEntrySchema: z.ZodObject<{
|
|
29
|
+
metricName: z.ZodString;
|
|
30
|
+
source: z.ZodString;
|
|
31
|
+
metric: z.ZodString;
|
|
32
|
+
nassMetricId: z.ZodOptional<z.ZodString>;
|
|
33
|
+
lastSeen: z.ZodOptional<z.ZodNumber>;
|
|
34
|
+
}, z.core.$loose>;
|
|
35
|
+
export type AnomalyGroupMetricsEntry = z.infer<typeof AnomalyGroupMetricsEntrySchema>;
|
|
36
|
+
export declare const AnomalyGroupMetricsResponseSchema: z.ZodObject<{
|
|
37
|
+
totalMetrics: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
|
|
38
|
+
pageSize: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
|
|
39
|
+
metrics: z.ZodArray<z.ZodObject<{
|
|
40
|
+
metricName: z.ZodString;
|
|
41
|
+
source: z.ZodString;
|
|
42
|
+
metric: z.ZodString;
|
|
43
|
+
nassMetricId: z.ZodOptional<z.ZodString>;
|
|
44
|
+
lastSeen: z.ZodOptional<z.ZodNumber>;
|
|
45
|
+
}, z.core.$loose>>;
|
|
46
|
+
exceedLimit: z.ZodOptional<z.ZodBoolean>;
|
|
47
|
+
}, z.core.$loose>;
|
|
48
|
+
export type AnomalyGroupMetricsResponse = z.infer<typeof AnomalyGroupMetricsResponseSchema>;
|
|
49
|
+
/** Request for `POST oi/v2/metricconfig/metric/fields` — the per-product field catalog. */
|
|
50
|
+
export declare const AnomalyMetricFieldsRequestSchema: z.ZodObject<{
|
|
51
|
+
product: z.ZodString;
|
|
52
|
+
}, z.core.$loose>;
|
|
53
|
+
export type AnomalyMetricFieldsRequest = z.infer<typeof AnomalyMetricFieldsRequestSchema>;
|
|
54
|
+
/**
|
|
55
|
+
* Builds the preview request the way the UI does: flat atoms grouped into one
|
|
56
|
+
* or-block per field — the only `customFilter` shape the server evaluates
|
|
57
|
+
* correctly (see `MetricConfigCustomFilterSchema`).
|
|
58
|
+
*/
|
|
59
|
+
export declare function toAnomalyGroupMetricsRequest(filters: MetricConfigFilter[], product: string, pageSize?: number): AnomalyGroupMetricsRequest;
|
|
60
|
+
/**
|
|
61
|
+
* Response of `metric/fields` for a product: `path` fields (`sourceName`,
|
|
62
|
+
* `attributeName`), `Service` (condition `equals`), and every metadata
|
|
63
|
+
* attribute the product's metrics carry. A filter on a field NOT in this
|
|
64
|
+
* catalog silently matches nothing.
|
|
65
|
+
*/
|
|
66
|
+
export declare const AnomalyMetricFieldsResponseSchema: z.ZodArray<z.ZodObject<{
|
|
67
|
+
fieldDescription: z.ZodString;
|
|
68
|
+
field: z.ZodString;
|
|
69
|
+
type: z.ZodString;
|
|
70
|
+
values: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
|
|
71
|
+
conditions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
|
|
72
|
+
}, z.core.$loose>>;
|
|
73
|
+
export type AnomalyMetricFieldsResponse = z.infer<typeof AnomalyMetricFieldsResponseSchema>;
|
|
74
|
+
//# sourceMappingURL=metrics-preview.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"metrics-preview.d.ts","sourceRoot":"","sources":["../../../../../src/lib/model/metric-anomaly/metrics-preview.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAG3B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAGjE;;;;;GAKG;AACH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;iBAI3C,CAAC;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAE1F,eAAO,MAAM,8BAA8B;;;;;;iBAMzC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AAEtF,eAAO,MAAM,iCAAiC;;;;;;;;;;;iBAO5C,CAAC;AACH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAE5F,2FAA2F;AAC3F,eAAO,MAAM,gCAAgC;;iBAE3C,CAAC;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAE1F;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,kBAAkB,EAAE,EAC7B,OAAO,EAAE,MAAM,EACf,QAAQ,SAAM,GACb,0BAA0B,CAM5B;AAED;;;;;GAKG;AACH,eAAO,MAAM,iCAAiC;;;;;;kBAEgB,CAAC;AAC/D,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC"}
|
|
@@ -0,0 +1,63 @@
|
|
|
1
|
+
import { z } from 'zod/v4';
|
|
2
|
+
import type { AnomalyDetectionGroup } from './group';
|
|
3
|
+
/**
|
|
4
|
+
* Request body for `POST oi/v2/metricconfig/groups/save` for an
|
|
5
|
+
* anomaly-detection group. `groupId` absent → create; present → update that
|
|
6
|
+
* group. The UI's create sends a minimal `anomalyAlertConfig`
|
|
7
|
+
* (`{enabled, useSystemSettings: true}`); updates send the full stored config.
|
|
8
|
+
*/
|
|
9
|
+
export declare const AnomalyDetectionGroupSaveRequestSchema: z.ZodObject<{
|
|
10
|
+
groupName: z.ZodString;
|
|
11
|
+
description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
12
|
+
filters: z.ZodArray<z.ZodObject<{
|
|
13
|
+
fieldDescription: z.ZodString;
|
|
14
|
+
field: z.ZodString;
|
|
15
|
+
value: z.ZodString;
|
|
16
|
+
condition: z.ZodString;
|
|
17
|
+
}, z.core.$loose>>;
|
|
18
|
+
product: z.ZodString;
|
|
19
|
+
anomalyAlertConfig: z.ZodObject<{
|
|
20
|
+
enabled: z.ZodBoolean;
|
|
21
|
+
useSystemSettings: z.ZodOptional<z.ZodBoolean>;
|
|
22
|
+
timeOverThreshold: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
|
|
23
|
+
unit: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
24
|
+
observationTime: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
|
|
25
|
+
countOverThreshold: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
|
|
26
|
+
observationCount: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
|
|
27
|
+
deviationPercentage: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
|
|
28
|
+
deviationValue: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
|
|
29
|
+
deviationValueOp: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
30
|
+
threshold: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
|
|
31
|
+
alarmSeverity: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
32
|
+
alarmMessage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
33
|
+
policyId: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
|
|
34
|
+
acType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
35
|
+
}, z.core.$loose>;
|
|
36
|
+
defaultGroup: z.ZodOptional<z.ZodBoolean>;
|
|
37
|
+
groupId: z.ZodOptional<z.ZodNumber>;
|
|
38
|
+
}, z.core.$loose>;
|
|
39
|
+
export type AnomalyDetectionGroupSaveRequest = z.infer<typeof AnomalyDetectionGroupSaveRequestSchema>;
|
|
40
|
+
/** Response from `groups/save`. */
|
|
41
|
+
export declare const AnomalyDetectionGroupSaveResponseSchema: z.ZodObject<{
|
|
42
|
+
groupId: z.ZodNumber;
|
|
43
|
+
message: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
44
|
+
status: z.ZodString;
|
|
45
|
+
}, z.core.$loose>;
|
|
46
|
+
export type AnomalyDetectionGroupSaveResponse = z.infer<typeof AnomalyDetectionGroupSaveResponseSchema>;
|
|
47
|
+
/**
|
|
48
|
+
* Response from `DELETE oi/v2/metricconfig/groups` with body
|
|
49
|
+
* `{groupIds: [<id>]}` (no `type` — the typed variant is the SLI delete).
|
|
50
|
+
*/
|
|
51
|
+
export declare const AnomalyDetectionGroupDeleteResponseSchema: z.ZodObject<{
|
|
52
|
+
message: z.ZodOptional<z.ZodString>;
|
|
53
|
+
status: z.ZodString;
|
|
54
|
+
}, z.core.$loose>;
|
|
55
|
+
export type AnomalyDetectionGroupDeleteResponse = z.infer<typeof AnomalyDetectionGroupDeleteResponseSchema>;
|
|
56
|
+
/**
|
|
57
|
+
* Projects a stored group onto the writable save body for an UPDATE — drops
|
|
58
|
+
* the read-only server fields, carries `groupId` and the full
|
|
59
|
+
* `anomalyAlertConfig` (so an update never resets alert settings), and
|
|
60
|
+
* applies `overrides` on top.
|
|
61
|
+
*/
|
|
62
|
+
export declare function toAnomalyDetectionGroupSaveRequest(group: AnomalyDetectionGroup, overrides?: Partial<Pick<AnomalyDetectionGroupSaveRequest, 'groupName' | 'description' | 'filters' | 'product' | 'anomalyAlertConfig'>>): AnomalyDetectionGroupSaveRequest;
|
|
63
|
+
//# sourceMappingURL=save.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"save.d.ts","sourceRoot":"","sources":["../../../../../src/lib/model/metric-anomaly/save.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAI3B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAErD;;;;;GAKG;AACH,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAWjD,CAAC;AACH,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CACpD,OAAO,sCAAsC,CAC9C,CAAC;AAEF,mCAAmC;AACnC,eAAO,MAAM,uCAAuC;;;;iBAIlD,CAAC;AACH,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CACrD,OAAO,uCAAuC,CAC/C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,yCAAyC;;;iBAGpD,CAAC;AACH,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,yCAAyC,CACjD,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,qBAAqB,EAC5B,SAAS,GAAE,OAAO,CAChB,IAAI,CACF,gCAAgC,EAChC,WAAW,GAAG,aAAa,GAAG,SAAS,GAAG,SAAS,GAAG,oBAAoB,CAC3E,CACG,GACL,gCAAgC,CASlC"}
|
|
@@ -0,0 +1,63 @@
|
|
|
1
|
+
import { z } from 'zod/v4';
|
|
2
|
+
/**
|
|
3
|
+
* Request body for `POST oi/v2/metricconfig/groups/search` when listing
|
|
4
|
+
* anomaly-detection groups. Unlike the SLI search there is NO `type` — the
|
|
5
|
+
* untyped search returns the anomaly groups in `metricGroups`.
|
|
6
|
+
*/
|
|
7
|
+
export declare const AnomalyDetectionGroupSearchRequestSchema: z.ZodObject<{
|
|
8
|
+
like: z.ZodString;
|
|
9
|
+
pageSize: z.ZodNumber;
|
|
10
|
+
sortCol: z.ZodString;
|
|
11
|
+
customFilter: z.ZodRecord<z.ZodString, z.ZodUnknown>;
|
|
12
|
+
}, z.core.$loose>;
|
|
13
|
+
export type AnomalyDetectionGroupSearchRequest = z.infer<typeof AnomalyDetectionGroupSearchRequestSchema>;
|
|
14
|
+
/**
|
|
15
|
+
* Response from the untyped `groups/search`: the groups plus the tenant-wide
|
|
16
|
+
* anomaly-detection budget (`enabledMetrics` of `allowedMetricsPerTenant`).
|
|
17
|
+
*/
|
|
18
|
+
export declare const AnomalyDetectionGroupSearchResponseSchema: z.ZodObject<{
|
|
19
|
+
totalGroups: z.ZodOptional<z.ZodNumber>;
|
|
20
|
+
pageSize: z.ZodOptional<z.ZodNumber>;
|
|
21
|
+
enabledMetrics: z.ZodOptional<z.ZodNumber>;
|
|
22
|
+
allowedMetricsPerTenant: z.ZodOptional<z.ZodNumber>;
|
|
23
|
+
exceedLimit: z.ZodOptional<z.ZodBoolean>;
|
|
24
|
+
metricGroups: z.ZodArray<z.ZodObject<{
|
|
25
|
+
groupName: z.ZodString;
|
|
26
|
+
groupId: z.ZodNumber;
|
|
27
|
+
filters: z.ZodArray<z.ZodObject<{
|
|
28
|
+
fieldDescription: z.ZodString;
|
|
29
|
+
field: z.ZodString;
|
|
30
|
+
value: z.ZodString;
|
|
31
|
+
condition: z.ZodString;
|
|
32
|
+
}, z.core.$loose>>;
|
|
33
|
+
description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
34
|
+
product: z.ZodString;
|
|
35
|
+
anomalyAlertConfig: z.ZodObject<{
|
|
36
|
+
enabled: z.ZodBoolean;
|
|
37
|
+
useSystemSettings: z.ZodOptional<z.ZodBoolean>;
|
|
38
|
+
timeOverThreshold: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
|
|
39
|
+
unit: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
40
|
+
observationTime: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
|
|
41
|
+
countOverThreshold: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
|
|
42
|
+
observationCount: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
|
|
43
|
+
deviationPercentage: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
|
|
44
|
+
deviationValue: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
|
|
45
|
+
deviationValueOp: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
46
|
+
threshold: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
|
|
47
|
+
alarmSeverity: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
48
|
+
alarmMessage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
49
|
+
policyId: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
|
|
50
|
+
acType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
51
|
+
}, z.core.$loose>;
|
|
52
|
+
defaultGroup: z.ZodOptional<z.ZodBoolean>;
|
|
53
|
+
serviceNames: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
|
|
54
|
+
creationTime: z.ZodOptional<z.ZodNumber>;
|
|
55
|
+
lastModifiedTime: z.ZodOptional<z.ZodNumber>;
|
|
56
|
+
createdBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
57
|
+
lastUpdatedBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
58
|
+
totalMetrics: z.ZodOptional<z.ZodNumber>;
|
|
59
|
+
breached: z.ZodOptional<z.ZodBoolean>;
|
|
60
|
+
}, z.core.$loose>>;
|
|
61
|
+
}, z.core.$loose>;
|
|
62
|
+
export type AnomalyDetectionGroupSearchResponse = z.infer<typeof AnomalyDetectionGroupSearchResponseSchema>;
|
|
63
|
+
//# sourceMappingURL=search.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../../../src/lib/model/metric-anomaly/search.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAI3B;;;;GAIG;AACH,eAAO,MAAM,wCAAwC;;;;;iBAOnD,CAAC;AACH,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CACtD,OAAO,wCAAwC,CAChD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiBpD,CAAC;AACH,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,yCAAyC,CACjD,CAAC"}
|
|
@@ -0,0 +1,60 @@
|
|
|
1
|
+
import { z } from 'zod/v4';
|
|
2
|
+
/**
|
|
3
|
+
* One filter atom of an OI metricconfig group — the match criteria shared by
|
|
4
|
+
* SLI groups (`type: "sli"`) and metric anomaly-detection groups (no type),
|
|
5
|
+
* e.g. "Source contains bd605" or "Metric regex java.lang\|Threading:.*".
|
|
6
|
+
* Groups persist a FLAT list of these; the server groups them by `field`.
|
|
7
|
+
*/
|
|
8
|
+
export declare const MetricConfigFilterSchema: z.ZodObject<{
|
|
9
|
+
fieldDescription: z.ZodString;
|
|
10
|
+
field: z.ZodString;
|
|
11
|
+
value: z.ZodString;
|
|
12
|
+
condition: z.ZodString;
|
|
13
|
+
}, z.core.$loose>;
|
|
14
|
+
export type MetricConfigFilter = z.infer<typeof MetricConfigFilterSchema>;
|
|
15
|
+
/** One `or` block of the preview expression tree: atoms on ONE field, OR-ed. */
|
|
16
|
+
export declare const MetricConfigFilterOrBlockSchema: z.ZodObject<{
|
|
17
|
+
or: z.ZodObject<{
|
|
18
|
+
expressions: z.ZodArray<z.ZodObject<{
|
|
19
|
+
fieldDescription: z.ZodString;
|
|
20
|
+
field: z.ZodString;
|
|
21
|
+
value: z.ZodString;
|
|
22
|
+
condition: z.ZodString;
|
|
23
|
+
}, z.core.$loose>>;
|
|
24
|
+
}, z.core.$loose>;
|
|
25
|
+
}, z.core.$loose>;
|
|
26
|
+
export type MetricConfigFilterOrBlock = z.infer<typeof MetricConfigFilterOrBlockSchema>;
|
|
27
|
+
/**
|
|
28
|
+
* The `customFilter` expression tree of `POST oi/v2/metricconfig/groups/metrics`.
|
|
29
|
+
*
|
|
30
|
+
* The server accepts exactly ONE shape: a root `and` whose children are `or`
|
|
31
|
+
* blocks, each holding atoms on a single field (probed on a lab tenant,
|
|
32
|
+
* 2026-10-01). Every other shape still answers HTTP 200 but is logically
|
|
33
|
+
* wrong — any nesting (a top-level `or`, an `and` inside an `or`, bare atoms
|
|
34
|
+
* under `and`) silently matches 0 metrics, and a mixed-field `or` block keeps
|
|
35
|
+
* only its first atom's field. So `(A∧B)∨(C∧D)` cannot be expressed in one
|
|
36
|
+
* group; use two. Build the tree with {@link orBlocksByField}, never by hand.
|
|
37
|
+
*/
|
|
38
|
+
export declare const MetricConfigCustomFilterSchema: z.ZodObject<{
|
|
39
|
+
and: z.ZodObject<{
|
|
40
|
+
expressions: z.ZodArray<z.ZodObject<{
|
|
41
|
+
or: z.ZodObject<{
|
|
42
|
+
expressions: z.ZodArray<z.ZodObject<{
|
|
43
|
+
fieldDescription: z.ZodString;
|
|
44
|
+
field: z.ZodString;
|
|
45
|
+
value: z.ZodString;
|
|
46
|
+
condition: z.ZodString;
|
|
47
|
+
}, z.core.$loose>>;
|
|
48
|
+
}, z.core.$loose>;
|
|
49
|
+
}, z.core.$loose>>;
|
|
50
|
+
}, z.core.$loose>;
|
|
51
|
+
}, z.core.$loose>;
|
|
52
|
+
export type MetricConfigCustomFilter = z.infer<typeof MetricConfigCustomFilterSchema>;
|
|
53
|
+
/**
|
|
54
|
+
* Groups flat filter atoms into the only tree shape the server evaluates
|
|
55
|
+
* correctly: one or-block per `field` (first-appearance order). Same-field
|
|
56
|
+
* atoms OR (a metric can `equals` any of four values); different fields must
|
|
57
|
+
* all match.
|
|
58
|
+
*/
|
|
59
|
+
export declare function orBlocksByField(filters: MetricConfigFilter[]): MetricConfigFilterOrBlock[];
|
|
60
|
+
//# sourceMappingURL=filter.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../../../../../src/lib/model/metricconfig/filter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAE3B;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB;;;;;iBAiBnC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,gFAAgF;AAChF,eAAO,MAAM,+BAA+B;;;;;;;;;iBAM1C,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAExF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;iBAQiB,CAAC;AAC7D,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AAEtF;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,kBAAkB,EAAE,GAAG,yBAAyB,EAAE,CAW1F"}
|
|
@@ -1,8 +1,9 @@
|
|
|
1
1
|
import { z } from 'zod/v4';
|
|
2
2
|
/**
|
|
3
3
|
* One row of an SLI group's match criteria. SLI groups select the metrics they
|
|
4
|
-
* watch by a list of these
|
|
5
|
-
* "Metric ends with Web Agent Status")
|
|
4
|
+
* watch by a list of these filters (e.g. "Source contains bd605" AND
|
|
5
|
+
* "Metric ends with Web Agent Status") — the metricconfig filter atom shared
|
|
6
|
+
* with anomaly-detection groups.
|
|
6
7
|
*/
|
|
7
8
|
export declare const SliFilterSchema: z.ZodObject<{
|
|
8
9
|
fieldDescription: z.ZodString;
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"group.d.ts","sourceRoot":"","sources":["../../../../../src/lib/model/sli/group.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;
|
|
1
|
+
{"version":3,"file":"group.d.ts","sourceRoot":"","sources":["../../../../../src/lib/model/sli/group.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAI3B;;;;;GAKG;AACH,eAAO,MAAM,eAAe;;;;;iBAA2B,CAAC;AACxD,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqDzB,CAAC;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC"}
|
|
@@ -1,5 +1,13 @@
|
|
|
1
1
|
import { z } from 'zod/v4';
|
|
2
2
|
import type { SliFilter } from './group';
|
|
3
|
+
/**
|
|
4
|
+
* Model for `POST oi/v2/metricconfig/groups/metrics` — the metric-match
|
|
5
|
+
* preview the DXO2 UI calls while a group's filters are edited. Given filter
|
|
6
|
+
* atoms and service bindings it returns the currently-matching metrics, which
|
|
7
|
+
* is exactly the feedback a create/add dry-run needs ("your filters match N
|
|
8
|
+
* metrics") and the fastest way to diagnose `sliStatusCode` 5 ("no metrics
|
|
9
|
+
* matching").
|
|
10
|
+
*/
|
|
3
11
|
export declare const SliGroupMetricsRequestSchema: z.ZodObject<{
|
|
4
12
|
numericFilter: z.ZodBoolean;
|
|
5
13
|
serviceNames: z.ZodArray<z.ZodString>;
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"metrics-preview.d.ts","sourceRoot":"","sources":["../../../../../src/lib/model/sli/metrics-preview.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAG3B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;
|
|
1
|
+
{"version":3,"file":"metrics-preview.d.ts","sourceRoot":"","sources":["../../../../../src/lib/model/sli/metrics-preview.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAG3B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC;;;;;;;GAOG;AAEH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;iBAKvC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAElF,eAAO,MAAM,0BAA0B;;;;;;;iBAOrC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,eAAO,MAAM,6BAA6B;;;;;;;;;;;;iBAUxC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAEpF;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB;;;;;;iBAM/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,eAAO,MAAM,4BAA4B;;iBAEvC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAElF,eAAO,MAAM,6BAA6B;;;;;;kBAEqB,CAAC;AAChE,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAEpF;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,SAAS,EAAE,EACpB,YAAY,EAAE,MAAM,EAAE,EACtB,QAAQ,SAAM,EACd,iBAAiB,GAAE,SAAS,EAAO,GAClC,sBAAsB,CAWxB"}
|
|
@@ -281,7 +281,7 @@ export declare class DxSaasService implements DXAPMSaaSService {
|
|
|
281
281
|
* @param params - Query-string parameters.
|
|
282
282
|
* @param extraHeaders - Additional request headers.
|
|
283
283
|
*/
|
|
284
|
-
accStream(path: string, params?: unknown, extraHeaders?: DXRequestHeaders): Promise<AxiosResponse<Stream, any, {}>>;
|
|
284
|
+
accStream(path: string, params?: unknown, extraHeaders?: DXRequestHeaders): Promise<AxiosResponse<Stream, any, {}, any>>;
|
|
285
285
|
/**
|
|
286
286
|
* GET from an ACC path.
|
|
287
287
|
* @param path - Path segment appended after `.../acc/`.
|
|
@@ -310,7 +310,7 @@ export declare class DxSaasService implements DXAPMSaaSService {
|
|
|
310
310
|
* (e.g. ACC `_links.download.href`) that reject the user-auth bearer.
|
|
311
311
|
* @param url - Fully-qualified URL to GET.
|
|
312
312
|
*/
|
|
313
|
-
streamFromURL(url: string): Promise<AxiosResponse<Stream, any, {}>>;
|
|
313
|
+
streamFromURL(url: string): Promise<AxiosResponse<Stream, any, {}, any>>;
|
|
314
314
|
/**
|
|
315
315
|
* GET an arbitrary public URL and return the raw response body as text.
|
|
316
316
|
* Used by `TenantService` to read the Broadcom status page for *platform*
|