@dx-do/client 7.16.0 → 7.17.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/dist/index.cjs.js +1468 -123
- package/dist/index.cjs.js.map +1 -1
- package/dist/index.esm.js +1466 -124
- package/dist/index.esm.js.map +1 -1
- package/dist/src/index.d.ts +3 -0
- package/dist/src/index.d.ts.map +1 -1
- package/dist/src/lib/model/datastore/datastore-schemas.d.ts +2 -7
- package/dist/src/lib/model/datastore/datastore-schemas.d.ts.map +1 -1
- package/dist/src/lib/model/datastore/metrics-metadata/attribute-name-specifier.d.ts +2 -2
- package/dist/src/lib/model/datastore/metrics-metadata/folder-name-specifier.d.ts +2 -2
- package/dist/src/lib/model/datastore/metrics-metadata/source-name-specifier.d.ts +2 -2
- package/dist/src/lib/model/datastore/nassql/operations.d.ts.map +1 -1
- package/dist/src/lib/model/oi/services.bulk-select.d.ts +109 -0
- package/dist/src/lib/model/oi/services.bulk-select.d.ts.map +1 -0
- package/dist/src/lib/model/oi/services.bulk.d.ts +243 -0
- package/dist/src/lib/model/oi/services.bulk.d.ts.map +1 -0
- package/dist/src/lib/model/oi/services.export.d.ts +10 -0
- package/dist/src/lib/model/oi/services.export.d.ts.map +1 -1
- package/dist/src/lib/model/oi/services.import.d.ts +43 -0
- package/dist/src/lib/model/oi/services.import.d.ts.map +1 -0
- package/dist/src/lib/model/oi/services.transform.d.ts +10 -1
- package/dist/src/lib/model/oi/services.transform.d.ts.map +1 -1
- package/dist/src/lib/model/service/service-overview.d.ts +20 -0
- package/dist/src/lib/model/service/service-overview.d.ts.map +1 -1
- package/dist/src/lib/services/service.service.d.ts +89 -6
- package/dist/src/lib/services/service.service.d.ts.map +1 -1
- package/package.json +1 -1
package/dist/index.esm.js
CHANGED
|
@@ -48461,6 +48461,21 @@ factory(name$9, ['typed', 'equalScalar'], _ref2 => {
|
|
|
48461
48461
|
});
|
|
48462
48462
|
});
|
|
48463
48463
|
|
|
48464
|
+
function cyrb53(str, seed = 0) {
|
|
48465
|
+
let h1 = 0xdeadbeef ^ seed;
|
|
48466
|
+
let h2 = 0x41c6ce57 ^ seed;
|
|
48467
|
+
for (let i = 0, ch; i < str.length; i++) {
|
|
48468
|
+
ch = str.charCodeAt(i);
|
|
48469
|
+
h1 = Math.imul(h1 ^ ch, 2654435761);
|
|
48470
|
+
h2 = Math.imul(h2 ^ ch, 1597334677);
|
|
48471
|
+
}
|
|
48472
|
+
h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507);
|
|
48473
|
+
h1 ^= Math.imul(h2 ^ (h2 >>> 13), 3266489909);
|
|
48474
|
+
h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507);
|
|
48475
|
+
h2 ^= Math.imul(h1 ^ (h1 >>> 13), 3266489909);
|
|
48476
|
+
return 4294967296 * (2097151 & h2) + (h1 >>> 0);
|
|
48477
|
+
}
|
|
48478
|
+
|
|
48464
48479
|
var Interpolation;
|
|
48465
48480
|
(function (Interpolation) {
|
|
48466
48481
|
function splitWithEscape(text, delimiter, escapeChar) {
|
|
@@ -50789,7 +50804,7 @@ const SourceNameNotSpecifierSchema = z.looseObject({
|
|
|
50789
50804
|
*/
|
|
50790
50805
|
const SourceNameExactSpecifierSchema = z.looseObject({
|
|
50791
50806
|
op: z.literal('EXACT'),
|
|
50792
|
-
names: z.array(z.string()).
|
|
50807
|
+
names: z.array(z.string()).describe('Exact source name strings; any matching name passes. Required: without it the server answers 400 "EXACT specifier - names field is required" (an empty list is accepted)'),
|
|
50793
50808
|
ignoreCase: z.boolean().optional().describe('Case-insensitive comparison; default false'),
|
|
50794
50809
|
});
|
|
50795
50810
|
/**
|
|
@@ -50798,7 +50813,7 @@ const SourceNameExactSpecifierSchema = z.looseObject({
|
|
|
50798
50813
|
*/
|
|
50799
50814
|
const SourceNameRegExSpecifierSchema = z.looseObject({
|
|
50800
50815
|
op: z.literal('REGEX'),
|
|
50801
|
-
pattern: z.string().
|
|
50816
|
+
pattern: z.string().describe('Java regex pattern matched against the full source name. Required, and named `pattern`: without it the server answers 400 "REGEX specifier - specifier field is required", naming the wrong field'),
|
|
50802
50817
|
ignoreCase: z.boolean().optional().describe('Case-insensitive match; default false'),
|
|
50803
50818
|
});
|
|
50804
50819
|
/**
|
|
@@ -50883,7 +50898,7 @@ const FolderNameNotSpecifierSchema = z.looseObject({
|
|
|
50883
50898
|
*/
|
|
50884
50899
|
const FolderNameExactSpecifierSchema = z.looseObject({
|
|
50885
50900
|
op: z.literal('EXACT'),
|
|
50886
|
-
names: z.array(z.string()).
|
|
50901
|
+
names: z.array(z.string()).describe('Exact folder name strings; any matching name passes. Required: without it the server answers 400 "EXACT specifier - names field is required" (an empty list is accepted)'),
|
|
50887
50902
|
ignoreCase: z.boolean().optional().describe('Case-insensitive comparison; default false'),
|
|
50888
50903
|
});
|
|
50889
50904
|
/**
|
|
@@ -50892,7 +50907,7 @@ const FolderNameExactSpecifierSchema = z.looseObject({
|
|
|
50892
50907
|
*/
|
|
50893
50908
|
const FolderNameRegExSpecifierSchema = z.looseObject({
|
|
50894
50909
|
op: z.literal('REGEX'),
|
|
50895
|
-
pattern: z.string().
|
|
50910
|
+
pattern: z.string().describe('Java regex pattern matched against the full folder name. Required, and named `pattern`: without it the server answers 400 "REGEX specifier - specifier field is required", naming the wrong field'),
|
|
50896
50911
|
ignoreCase: z.boolean().optional().describe('Case-insensitive match; default false'),
|
|
50897
50912
|
});
|
|
50898
50913
|
/**
|
|
@@ -51000,7 +51015,7 @@ const AttributeNameNotSpecifierSchema = z.looseObject({
|
|
|
51000
51015
|
*/
|
|
51001
51016
|
const AttributeNameExactSpecifierSchema = z.looseObject({
|
|
51002
51017
|
op: z.literal('EXACT'),
|
|
51003
|
-
names: z.array(z.string()).
|
|
51018
|
+
names: z.array(z.string()).describe('Exact attribute name strings. Required: without it the server answers 400 "EXACT specifier - names field is required" (an empty list is accepted)'),
|
|
51004
51019
|
type: z.number().optional().describe('Optional attribute type bitmask filter'),
|
|
51005
51020
|
ignoreCase: z.boolean().optional().describe('Case-insensitive comparison; default false'),
|
|
51006
51021
|
});
|
|
@@ -51010,7 +51025,7 @@ const AttributeNameExactSpecifierSchema = z.looseObject({
|
|
|
51010
51025
|
*/
|
|
51011
51026
|
const AttributeNameRegExSpecifierSchema = z.looseObject({
|
|
51012
51027
|
op: z.literal('REGEX'),
|
|
51013
|
-
pattern: z.string().
|
|
51028
|
+
pattern: z.string().describe('Java regex pattern matched against the full attribute name. Required, and named `pattern`: without it the server answers 400 "REGEX specifier - specifier field is required", naming the wrong field'),
|
|
51014
51029
|
ignoreCase: z.boolean().optional().describe('Case-insensitive match; default false'),
|
|
51015
51030
|
});
|
|
51016
51031
|
/**
|
|
@@ -51999,17 +52014,17 @@ const QueryCalendarWindowSpecSchema = z.looseObject({
|
|
|
51999
52014
|
* per-entity grouping column to survive into `KEEP` — otherwise WINDOW
|
|
52000
52015
|
* + aggregation collapses non-grouped columns away.
|
|
52001
52016
|
*
|
|
52002
|
-
*
|
|
52003
|
-
*
|
|
52004
|
-
*
|
|
52017
|
+
* An empty `columns[]` clears the grouping. It is what makes `TOP` /
|
|
52018
|
+
* `BOTTOM` rank across rows after `GROUP` › an aggregation: without it they
|
|
52019
|
+
* rank within each group and every group comes back (measured on
|
|
52020
|
+
* THE_LABORATORY 2026-10-23: 42 sources, `TOP` 10 returned all 42; after
|
|
52021
|
+
* `GROUP []` it returned the 10 largest, in order).
|
|
52005
52022
|
*/
|
|
52006
52023
|
const QueryGroupSpecSchema = z.looseObject({
|
|
52007
52024
|
op: z.literal('GROUP'),
|
|
52008
|
-
// No grouping key = no grouping; server rejects empty.
|
|
52009
52025
|
columns: z
|
|
52010
52026
|
.array(z.string())
|
|
52011
|
-
.
|
|
52012
|
-
.describe('Compound grouping-key columns; must be non-empty'),
|
|
52027
|
+
.describe('Compound grouping-key columns. Empty clears the grouping: put GROUP [] after an aggregation and before TOP / BOTTOM so they rank across all rows, not within each group'),
|
|
52013
52028
|
});
|
|
52014
52029
|
/**
|
|
52015
52030
|
* `ORDER` — SQL-style multi-key sort. Mixed types are ordered: nulls
|
|
@@ -52940,6 +52955,27 @@ function discriminatorValueOf(option) {
|
|
|
52940
52955
|
*
|
|
52941
52956
|
* Order matches the union's declaration; not alphabetical.
|
|
52942
52957
|
*/
|
|
52958
|
+
/** The name specifiers a Metrics Metadata `SPEC` holds, each a union of its own ops (REGEX, EXACT, …). */
|
|
52959
|
+
const NAME_SPECIFIERS = [
|
|
52960
|
+
{ field: 'sourceNameSpecifier', union: SourceNameSpecifierSchema },
|
|
52961
|
+
{ field: 'attributeNameSpecifier', union: AttributeNameSpecifierSchema },
|
|
52962
|
+
{ field: 'folderNameSpecifier', union: FolderNameSpecifierSchema },
|
|
52963
|
+
];
|
|
52964
|
+
const optionsOf = (union) => union.options ?? [];
|
|
52965
|
+
/** The name-specifier ops, which a SPEC (metadata, or a NASSQL FROM / FROM_METADATA `querySpecifier`) carries. */
|
|
52966
|
+
function listNameSpecifierOps() {
|
|
52967
|
+
return [...new Set(NAME_SPECIFIERS.flatMap(({ union }) => optionsOf(union).map(discriminatorValueOf).filter((v) => !!v)))];
|
|
52968
|
+
}
|
|
52969
|
+
/** A name-specifier op's schema, saying which SPEC fields it goes in (#1195); undefined when `op` is none. */
|
|
52970
|
+
function nameSpecifierSchema(op) {
|
|
52971
|
+
const found = NAME_SPECIFIERS.flatMap(({ field, union }) => optionsOf(union).filter((o) => discriminatorValueOf(o) === op).map((o) => ({ field, o })));
|
|
52972
|
+
const first = found[0];
|
|
52973
|
+
if (!first)
|
|
52974
|
+
return undefined;
|
|
52975
|
+
const json = z$1.toJSONSchema(first.o);
|
|
52976
|
+
const where = `A name-specifier op: it goes in a SPEC's ${found.map((f) => f.field).join(' / ')}, not at the top level.`;
|
|
52977
|
+
return { ...json, description: typeof json['description'] === 'string' ? `${json['description']} ${where}` : where };
|
|
52978
|
+
}
|
|
52943
52979
|
function listDataStoreSchemaOps(type) {
|
|
52944
52980
|
const { union } = resolveSchemas(type);
|
|
52945
52981
|
const out = [];
|
|
@@ -52979,8 +53015,14 @@ function getDataStoreSchema(type, op) {
|
|
|
52979
53015
|
return z$1.toJSONSchema(opt);
|
|
52980
53016
|
}
|
|
52981
53017
|
}
|
|
53018
|
+
if (type !== 'tas') {
|
|
53019
|
+
const named = nameSpecifierSchema(op);
|
|
53020
|
+
if (named)
|
|
53021
|
+
return named;
|
|
53022
|
+
}
|
|
52982
53023
|
const valid = listDataStoreSchemaOps(type);
|
|
52983
|
-
|
|
53024
|
+
const names = type === 'tas' ? '' : `; inside a SPEC's name specifiers: ${listNameSpecifierOps().join(', ')}`;
|
|
53025
|
+
throw new Error(`Unknown ${type} op "${op}". Valid ops: ${valid.join(', ')}${names}`);
|
|
52984
53026
|
}
|
|
52985
53027
|
function describeType(prop) {
|
|
52986
53028
|
if (Array.isArray(prop['oneOf'])) {
|
|
@@ -63794,57 +63836,6 @@ var CreateServices;
|
|
|
63794
63836
|
CreateServices.SERVICE_TYPES = ['Service', 'Application', 'Group'];
|
|
63795
63837
|
})(CreateServices || (CreateServices = {}));
|
|
63796
63838
|
|
|
63797
|
-
/**
|
|
63798
|
-
* The `service export` / `service export-hierarchy` file format and the
|
|
63799
|
-
* `service import` boundary validator.
|
|
63800
|
-
*
|
|
63801
|
-
* The envelope wraps a re-postable store body ({@link CreateServices.CreateServiceBody})
|
|
63802
|
-
* with provenance metadata. `import` accepts either the envelope or a bare body.
|
|
63803
|
-
*/
|
|
63804
|
-
var ServiceExport;
|
|
63805
|
-
(function (ServiceExport) {
|
|
63806
|
-
ServiceExport.SCHEMA_VERSION = 1;
|
|
63807
|
-
// Structural guard for a store body — does not re-validate every field
|
|
63808
|
-
// (the server is the authority); just enough to reject obviously-wrong files.
|
|
63809
|
-
const BodyShape = z.looseObject({
|
|
63810
|
-
vertices: z.array(z.looseObject({ attributes: z.looseObject({ name: z.string() }) })),
|
|
63811
|
-
edges: z.array(z.looseObject({
|
|
63812
|
-
sourceExternalId: z.string(),
|
|
63813
|
-
targetExternalId: z.string(),
|
|
63814
|
-
})),
|
|
63815
|
-
});
|
|
63816
|
-
const EnvelopeShape = z.looseObject({
|
|
63817
|
-
schemaVersion: z.literal(1),
|
|
63818
|
-
kind: z.enum(['service', 'service-hierarchy']),
|
|
63819
|
-
sourceTenant: z.string().optional(),
|
|
63820
|
-
exportedAt: z.string(),
|
|
63821
|
-
body: BodyShape,
|
|
63822
|
-
});
|
|
63823
|
-
/** Wrap a store body in an export envelope. */
|
|
63824
|
-
function envelope(kind, body, sourceTenant, exportedAt) {
|
|
63825
|
-
return { schemaVersion: ServiceExport.SCHEMA_VERSION, kind, sourceTenant, exportedAt, body };
|
|
63826
|
-
}
|
|
63827
|
-
ServiceExport.envelope = envelope;
|
|
63828
|
-
/**
|
|
63829
|
-
* Validate an import file (already JSON-parsed) and return the store body.
|
|
63830
|
-
* Accepts a full export envelope or a bare `{ vertices, edges }` body.
|
|
63831
|
-
* @throws Error when the input is neither shape.
|
|
63832
|
-
*/
|
|
63833
|
-
function parseImport(raw) {
|
|
63834
|
-
const asEnvelope = EnvelopeShape.safeParse(raw);
|
|
63835
|
-
if (asEnvelope.success) {
|
|
63836
|
-
return asEnvelope.data.body;
|
|
63837
|
-
}
|
|
63838
|
-
const asBody = BodyShape.safeParse(raw);
|
|
63839
|
-
if (asBody.success) {
|
|
63840
|
-
return raw;
|
|
63841
|
-
}
|
|
63842
|
-
throw new Error('Import file is neither a service export envelope nor a bare {vertices, edges} body. ' +
|
|
63843
|
-
`Envelope error: ${asEnvelope.error.message}`);
|
|
63844
|
-
}
|
|
63845
|
-
ServiceExport.parseImport = parseImport;
|
|
63846
|
-
})(ServiceExport || (ServiceExport = {}));
|
|
63847
|
-
|
|
63848
63839
|
/**
|
|
63849
63840
|
* Pure (HTTP-free) transforms between the Service read shapes and the store
|
|
63850
63841
|
* (`/oi/v2/sa/save`) body. Kept separate from {@link ServiceService} so the
|
|
@@ -63971,6 +63962,7 @@ var ServiceTransform;
|
|
|
63971
63962
|
* dropped — this is exactly the incoming edge(s) from the root's parent, which
|
|
63972
63963
|
* `saTopologyGraph` returns without the parent vertex (and which must not be
|
|
63973
63964
|
* re-posted: the parent isn't re-saved, so its edge survives anyway).
|
|
63965
|
+
* Also accepts a `?subservices=true` read, which has the same id/edge shape.
|
|
63974
63966
|
*/
|
|
63975
63967
|
function edgesFromTopology(topo) {
|
|
63976
63968
|
const idToName = new Map(topo.vertices.map((v) => [v.externalId, v.attributes.name]));
|
|
@@ -64089,6 +64081,915 @@ var ServiceTransform;
|
|
|
64089
64081
|
ServiceTransform.assertWeightsWithinLimit = assertWeightsWithinLimit;
|
|
64090
64082
|
})(ServiceTransform || (ServiceTransform = {}));
|
|
64091
64083
|
|
|
64084
|
+
/**
|
|
64085
|
+
* Pure (HTTP-free) planning for multi-service edits saved in ONE `sa/save`.
|
|
64086
|
+
*
|
|
64087
|
+
* Measured on a lab tenant (docs/internal/service-bulk-save-findings-2026-10.md):
|
|
64088
|
+
* - Every vertex in a save payload is fully overwritten — attributes AND outgoing
|
|
64089
|
+
* edges — so a payload carries each changed service plus all its descendants,
|
|
64090
|
+
* each complete. Services left out of the payload are untouched, as are
|
|
64091
|
+
* incoming edges; a changed leaf is saved alone.
|
|
64092
|
+
* - A save that fails validation changes nothing.
|
|
64093
|
+
* - `GET sa/services/{name}?subservices=true` returns every hierarchy that
|
|
64094
|
+
* CONTAINS the service; descendants are computed from its edges here.
|
|
64095
|
+
*
|
|
64096
|
+
* Locking is a field-level rebase: a plan records the value each change
|
|
64097
|
+
* replaces; a commit re-reads, refuses only when one of those values moved
|
|
64098
|
+
* ({@link findConflicts}), then re-applies the changes onto the fresh read.
|
|
64099
|
+
*/
|
|
64100
|
+
var ServiceBulk;
|
|
64101
|
+
(function (ServiceBulk) {
|
|
64102
|
+
const ServiceNameSchema = z
|
|
64103
|
+
.string()
|
|
64104
|
+
.min(1)
|
|
64105
|
+
.describe('Service name: case-sensitive and unique in the tenant.');
|
|
64106
|
+
const TagsSchema = z
|
|
64107
|
+
.array(z.string().min(1))
|
|
64108
|
+
.min(1)
|
|
64109
|
+
.describe('Tags, compared as a set.');
|
|
64110
|
+
const WeightSchema = z
|
|
64111
|
+
.number()
|
|
64112
|
+
.min(0)
|
|
64113
|
+
.max(1)
|
|
64114
|
+
.describe("Fraction (0–1) of the child's health/risk rolled up into the parent; a parent's children may total at most 1.");
|
|
64115
|
+
const CustomPropertySchema = z.strictObject({
|
|
64116
|
+
name: z.string().min(1).describe('Custom property name.'),
|
|
64117
|
+
value: z.string().describe('Custom property value.'),
|
|
64118
|
+
});
|
|
64119
|
+
ServiceBulk.ServiceChangeSchema = z
|
|
64120
|
+
.discriminatedUnion('op', [
|
|
64121
|
+
z
|
|
64122
|
+
.strictObject({ op: z.literal('addTags'), service: ServiceNameSchema, tags: TagsSchema })
|
|
64123
|
+
.describe('Add tags to a service; tags it already has are left alone.'),
|
|
64124
|
+
z
|
|
64125
|
+
.strictObject({ op: z.literal('removeTags'), service: ServiceNameSchema, tags: TagsSchema })
|
|
64126
|
+
.describe('Remove tags from a service; tags it lacks are ignored.'),
|
|
64127
|
+
z
|
|
64128
|
+
.strictObject({
|
|
64129
|
+
op: z.literal('setProperty'),
|
|
64130
|
+
service: ServiceNameSchema,
|
|
64131
|
+
name: z.string().min(1).describe('Custom property name.'),
|
|
64132
|
+
value: z.string().describe('New value; replaces every existing value of the property.'),
|
|
64133
|
+
})
|
|
64134
|
+
.describe('Set one custom property, adding it when absent.'),
|
|
64135
|
+
z
|
|
64136
|
+
.strictObject({
|
|
64137
|
+
op: z.literal('removeProperty'),
|
|
64138
|
+
service: ServiceNameSchema,
|
|
64139
|
+
name: z.string().min(1).describe('Custom property name.'),
|
|
64140
|
+
})
|
|
64141
|
+
.describe('Remove one custom property; a property the service lacks is ignored.'),
|
|
64142
|
+
z
|
|
64143
|
+
.strictObject({
|
|
64144
|
+
op: z.literal('setAttributes'),
|
|
64145
|
+
service: ServiceNameSchema,
|
|
64146
|
+
description: z.string().optional().describe('New description.'),
|
|
64147
|
+
location: z.string().optional().describe('New location.'),
|
|
64148
|
+
situationsIncludeChildServices: z
|
|
64149
|
+
.boolean()
|
|
64150
|
+
.optional()
|
|
64151
|
+
.describe("Whether the service's situations include its child services."),
|
|
64152
|
+
})
|
|
64153
|
+
.describe('Set scalar attributes; omitted fields keep their values.'),
|
|
64154
|
+
z
|
|
64155
|
+
.strictObject({
|
|
64156
|
+
op: z.literal('createService'),
|
|
64157
|
+
service: ServiceNameSchema,
|
|
64158
|
+
serviceType: z
|
|
64159
|
+
.enum(CreateServices.SERVICE_TYPES)
|
|
64160
|
+
.optional()
|
|
64161
|
+
.describe('Service | Application | Group (default Service); fixed once created.'),
|
|
64162
|
+
description: z.string().optional().describe('Description (default empty).'),
|
|
64163
|
+
location: z.string().optional().describe('Location (default empty).'),
|
|
64164
|
+
tags: z.array(z.string().min(1)).optional().describe('Initial tags.'),
|
|
64165
|
+
customProperties: z
|
|
64166
|
+
.array(CustomPropertySchema)
|
|
64167
|
+
.optional()
|
|
64168
|
+
.describe('Initial custom properties.'),
|
|
64169
|
+
})
|
|
64170
|
+
.describe('Create a service; it is a top-level service unless a link change adds a parent.'),
|
|
64171
|
+
z
|
|
64172
|
+
.strictObject({
|
|
64173
|
+
op: z.literal('link'),
|
|
64174
|
+
parent: ServiceNameSchema,
|
|
64175
|
+
child: ServiceNameSchema,
|
|
64176
|
+
healthWeight: WeightSchema.optional(),
|
|
64177
|
+
riskWeight: WeightSchema.optional(),
|
|
64178
|
+
})
|
|
64179
|
+
.describe("Make child a direct child of parent, or re-weight an existing link. With no weights the parent's children are re-split evenly; one weight given sets both."),
|
|
64180
|
+
z
|
|
64181
|
+
.strictObject({ op: z.literal('unlink'), parent: ServiceNameSchema, child: ServiceNameSchema })
|
|
64182
|
+
.describe("Remove the parent→child link; the remaining children's weights are kept."),
|
|
64183
|
+
])
|
|
64184
|
+
.describe('One change to one service or to one parent→child link.');
|
|
64185
|
+
class ServiceConflictError extends Error {
|
|
64186
|
+
conflicts;
|
|
64187
|
+
constructor(conflicts) {
|
|
64188
|
+
super(`Services changed since the plan was made — re-plan to see the current state:\n ${conflicts.join('\n ')}`);
|
|
64189
|
+
this.conflicts = conflicts;
|
|
64190
|
+
}
|
|
64191
|
+
}
|
|
64192
|
+
ServiceBulk.ServiceConflictError = ServiceConflictError;
|
|
64193
|
+
const IGNORED_FIELDS = new Set(['metrics', 'root_service', 'type', 'state']);
|
|
64194
|
+
/** Parse untrusted changes (CLI file, MCP input); throws ZodError. */
|
|
64195
|
+
function parseChanges(raw) {
|
|
64196
|
+
return z.array(ServiceBulk.ServiceChangeSchema).min(1).parse(raw);
|
|
64197
|
+
}
|
|
64198
|
+
ServiceBulk.parseChanges = parseChanges;
|
|
64199
|
+
const ChildLinkSchema = z.looseObject({
|
|
64200
|
+
child: z.string(),
|
|
64201
|
+
healthWeight: z.number(),
|
|
64202
|
+
riskWeight: z.number(),
|
|
64203
|
+
});
|
|
64204
|
+
ServiceBulk.ServicePlanSchema = z
|
|
64205
|
+
.looseObject({
|
|
64206
|
+
targets: z.array(z.string()).describe('Services read to build the plan.'),
|
|
64207
|
+
changes: z.array(ServiceBulk.ServiceChangeSchema).min(1).describe('The changes, in order.'),
|
|
64208
|
+
diff: z
|
|
64209
|
+
.array(z.looseObject({
|
|
64210
|
+
service: z.string(),
|
|
64211
|
+
status: z.enum(['created', 'changed']),
|
|
64212
|
+
fields: z.array(z.looseObject({ field: z.string(), before: z.unknown(), after: z.unknown() })),
|
|
64213
|
+
children: z
|
|
64214
|
+
.looseObject({ before: z.array(ChildLinkSchema), after: z.array(ChildLinkSchema) })
|
|
64215
|
+
.optional(),
|
|
64216
|
+
}))
|
|
64217
|
+
.describe('Per-service before/after; the before values are what a commit checks.'),
|
|
64218
|
+
save: z.array(z.string()).describe('Every service the save payload carries.'),
|
|
64219
|
+
})
|
|
64220
|
+
.describe('A plan returned by planServiceChanges, passed back unchanged to commit it.');
|
|
64221
|
+
/** Parse an untrusted plan (file, MCP input); throws ZodError. */
|
|
64222
|
+
function parsePlan(raw) {
|
|
64223
|
+
return ServiceBulk.ServicePlanSchema.parse(raw);
|
|
64224
|
+
}
|
|
64225
|
+
ServiceBulk.parsePlan = parsePlan;
|
|
64226
|
+
/**
|
|
64227
|
+
* Every existing service the changes name — what to read before planning.
|
|
64228
|
+
* Services created by an earlier change in the list are excluded.
|
|
64229
|
+
*/
|
|
64230
|
+
function targetsOf(changes) {
|
|
64231
|
+
const created = new Set();
|
|
64232
|
+
const targets = new Set();
|
|
64233
|
+
for (const c of changes) {
|
|
64234
|
+
const names = c.op === 'link' || c.op === 'unlink' ? [c.parent, c.child] : [c.service];
|
|
64235
|
+
if (c.op === 'createService')
|
|
64236
|
+
created.add(c.service);
|
|
64237
|
+
for (const n of names)
|
|
64238
|
+
if (!created.has(n))
|
|
64239
|
+
targets.add(n);
|
|
64240
|
+
}
|
|
64241
|
+
return [...targets];
|
|
64242
|
+
}
|
|
64243
|
+
ServiceBulk.targetsOf = targetsOf;
|
|
64244
|
+
/**
|
|
64245
|
+
* Convert one `?subservices=true` read into a name-keyed graph.
|
|
64246
|
+
* @throws Error when the read is paged — never observed, so refused rather than guessed at.
|
|
64247
|
+
*/
|
|
64248
|
+
function graphFromRead(read) {
|
|
64249
|
+
const paged = (read.nextOffset !== undefined && read.nextOffset !== -1) ||
|
|
64250
|
+
(read.totalVertices !== undefined && read.vertices.length < read.totalVertices);
|
|
64251
|
+
if (paged) {
|
|
64252
|
+
throw new Error(`Service hierarchy read is paged (${read.vertices.length} of ${read.totalVertices} services, nextOffset=${read.nextOffset}); bulk edits do not support paged hierarchies yet`);
|
|
64253
|
+
}
|
|
64254
|
+
const vertices = {};
|
|
64255
|
+
for (const v of read.vertices) {
|
|
64256
|
+
vertices[v.attributes.name] = ServiceTransform.retrievedToServiceVertex(v);
|
|
64257
|
+
}
|
|
64258
|
+
return { vertices, edges: ServiceTransform.edgesFromTopology(read) };
|
|
64259
|
+
}
|
|
64260
|
+
ServiceBulk.graphFromRead = graphFromRead;
|
|
64261
|
+
/** Union two graphs; a service or edge present in both keeps the first copy. */
|
|
64262
|
+
function mergeGraphs(a, b) {
|
|
64263
|
+
return {
|
|
64264
|
+
vertices: { ...b.vertices, ...a.vertices },
|
|
64265
|
+
edges: ServiceTransform.mergeBodies({ vertices: [], edges: a.edges }, { vertices: [], edges: b.edges })
|
|
64266
|
+
.edges,
|
|
64267
|
+
};
|
|
64268
|
+
}
|
|
64269
|
+
ServiceBulk.mergeGraphs = mergeGraphs;
|
|
64270
|
+
/** Direct children of a parent, sorted by name. */
|
|
64271
|
+
function childLinks(graph, parent) {
|
|
64272
|
+
return ServiceTransform.childEdges(graph.edges, parent)
|
|
64273
|
+
.map((e) => ({
|
|
64274
|
+
child: e.targetExternalId,
|
|
64275
|
+
healthWeight: e.attributes.health_weight,
|
|
64276
|
+
riskWeight: e.attributes.risk_weight,
|
|
64277
|
+
}))
|
|
64278
|
+
.sort((x, y) => x.child.localeCompare(y.child));
|
|
64279
|
+
}
|
|
64280
|
+
ServiceBulk.childLinks = childLinks;
|
|
64281
|
+
/** The services reachable from the seeds through parent→child edges, seeds included. */
|
|
64282
|
+
function descendantClosure(graph, seeds) {
|
|
64283
|
+
const seen = new Set();
|
|
64284
|
+
const queue = [...seeds];
|
|
64285
|
+
while (queue.length) {
|
|
64286
|
+
const name = queue.shift();
|
|
64287
|
+
if (seen.has(name))
|
|
64288
|
+
continue;
|
|
64289
|
+
seen.add(name);
|
|
64290
|
+
for (const e of ServiceTransform.childEdges(graph.edges, name))
|
|
64291
|
+
queue.push(e.targetExternalId);
|
|
64292
|
+
}
|
|
64293
|
+
return [...seen];
|
|
64294
|
+
}
|
|
64295
|
+
ServiceBulk.descendantClosure = descendantClosure;
|
|
64296
|
+
/** The store body for a set of services: each one complete, with all its outgoing edges. */
|
|
64297
|
+
function bodyFor(graph, services) {
|
|
64298
|
+
const names = new Set(services);
|
|
64299
|
+
const missing = services.filter((n) => !graph.vertices[n]);
|
|
64300
|
+
if (missing.length)
|
|
64301
|
+
throw new Error(`Services not in the graph: ${missing.join(', ')}`);
|
|
64302
|
+
const edges = graph.edges.filter((e) => names.has(e.sourceExternalId));
|
|
64303
|
+
const dangling = edges.filter((e) => !names.has(e.targetExternalId));
|
|
64304
|
+
if (dangling.length) {
|
|
64305
|
+
throw new Error(`Edges leave the payload: ${dangling.map((e) => `${e.sourceExternalId}→${e.targetExternalId}`).join(', ')}`);
|
|
64306
|
+
}
|
|
64307
|
+
return { vertices: services.map((n) => graph.vertices[n]), edges };
|
|
64308
|
+
}
|
|
64309
|
+
ServiceBulk.bodyFor = bodyFor;
|
|
64310
|
+
/** A service and its whole subtree as one store body (export-hierarchy, associate, …). */
|
|
64311
|
+
function subtreeBody(graph, root) {
|
|
64312
|
+
if (!graph.vertices[root])
|
|
64313
|
+
throw new Error(`No service with name '${root}' found`);
|
|
64314
|
+
return bodyFor(graph, descendantClosure(graph, [root]));
|
|
64315
|
+
}
|
|
64316
|
+
ServiceBulk.subtreeBody = subtreeBody;
|
|
64317
|
+
function newVertex(c) {
|
|
64318
|
+
return {
|
|
64319
|
+
externalId: c.service,
|
|
64320
|
+
attributes: {
|
|
64321
|
+
type: 'saService',
|
|
64322
|
+
name: c.service,
|
|
64323
|
+
serviceType: c.serviceType ?? 'Service',
|
|
64324
|
+
state: 'ACTIVE',
|
|
64325
|
+
maintenance: false,
|
|
64326
|
+
situationsIncludeChildServices: false,
|
|
64327
|
+
serviceContent: [],
|
|
64328
|
+
root_service: null,
|
|
64329
|
+
tags: c.tags ? [...new Set(c.tags)] : [],
|
|
64330
|
+
location: c.location ?? '',
|
|
64331
|
+
description: c.description ?? '',
|
|
64332
|
+
customProperties: (c.customProperties ?? []).map((p) => ({ ...p })),
|
|
64333
|
+
customMetrics: [],
|
|
64334
|
+
metrics: [],
|
|
64335
|
+
},
|
|
64336
|
+
};
|
|
64337
|
+
}
|
|
64338
|
+
function isAncestor(graph, candidate, of) {
|
|
64339
|
+
return descendantClosure(graph, [candidate]).includes(of);
|
|
64340
|
+
}
|
|
64341
|
+
/**
|
|
64342
|
+
* Apply changes to a copy of the graph, in order.
|
|
64343
|
+
* @throws Error naming the offending change (unknown service, duplicate create, cycle, missing link).
|
|
64344
|
+
*/
|
|
64345
|
+
function applyChanges(graph, changes) {
|
|
64346
|
+
const g = structuredClone(graph);
|
|
64347
|
+
const vertex = (name, i) => {
|
|
64348
|
+
const v = g.vertices[name];
|
|
64349
|
+
if (!v)
|
|
64350
|
+
throw new Error(`change ${i + 1}: no service with name '${name}' found`);
|
|
64351
|
+
return v.attributes;
|
|
64352
|
+
};
|
|
64353
|
+
changes.forEach((c, i) => {
|
|
64354
|
+
switch (c.op) {
|
|
64355
|
+
case 'addTags': {
|
|
64356
|
+
const a = vertex(c.service, i);
|
|
64357
|
+
a.tags = [...new Set([...a.tags, ...c.tags])];
|
|
64358
|
+
break;
|
|
64359
|
+
}
|
|
64360
|
+
case 'removeTags': {
|
|
64361
|
+
const a = vertex(c.service, i);
|
|
64362
|
+
a.tags = a.tags.filter((t) => !c.tags.includes(t));
|
|
64363
|
+
break;
|
|
64364
|
+
}
|
|
64365
|
+
case 'setProperty': {
|
|
64366
|
+
const a = vertex(c.service, i);
|
|
64367
|
+
const rest = a.customProperties.filter((p) => p.name !== c.name);
|
|
64368
|
+
a.customProperties = [...rest, { name: c.name, value: c.value }];
|
|
64369
|
+
break;
|
|
64370
|
+
}
|
|
64371
|
+
case 'removeProperty': {
|
|
64372
|
+
const a = vertex(c.service, i);
|
|
64373
|
+
a.customProperties = a.customProperties.filter((p) => p.name !== c.name);
|
|
64374
|
+
break;
|
|
64375
|
+
}
|
|
64376
|
+
case 'setAttributes': {
|
|
64377
|
+
const a = vertex(c.service, i);
|
|
64378
|
+
if (c.description !== undefined)
|
|
64379
|
+
a.description = c.description;
|
|
64380
|
+
if (c.location !== undefined)
|
|
64381
|
+
a.location = c.location;
|
|
64382
|
+
if (c.situationsIncludeChildServices !== undefined) {
|
|
64383
|
+
a.situationsIncludeChildServices = c.situationsIncludeChildServices;
|
|
64384
|
+
}
|
|
64385
|
+
break;
|
|
64386
|
+
}
|
|
64387
|
+
case 'createService': {
|
|
64388
|
+
if (g.vertices[c.service]) {
|
|
64389
|
+
throw new Error(`change ${i + 1}: service '${c.service}' already exists`);
|
|
64390
|
+
}
|
|
64391
|
+
g.vertices[c.service] = newVertex(c);
|
|
64392
|
+
break;
|
|
64393
|
+
}
|
|
64394
|
+
case 'link': {
|
|
64395
|
+
vertex(c.parent, i);
|
|
64396
|
+
vertex(c.child, i);
|
|
64397
|
+
if (c.parent === c.child || isAncestor(g, c.child, c.parent)) {
|
|
64398
|
+
throw new Error(`change ${i + 1}: linking '${c.child}' under '${c.parent}' would create a cycle`);
|
|
64399
|
+
}
|
|
64400
|
+
const weighted = c.healthWeight !== undefined || c.riskWeight !== undefined;
|
|
64401
|
+
const exists = g.edges.some((e) => e.sourceExternalId === c.parent && e.targetExternalId === c.child);
|
|
64402
|
+
if (weighted) {
|
|
64403
|
+
const h = c.healthWeight ?? c.riskWeight;
|
|
64404
|
+
const r = c.riskWeight ?? h;
|
|
64405
|
+
g.edges = ServiceTransform.upsertEdge(g.edges, c.parent, c.child, h, r);
|
|
64406
|
+
}
|
|
64407
|
+
else if (!exists) {
|
|
64408
|
+
g.edges = ServiceTransform.rebalanceChildren(ServiceTransform.upsertEdge(g.edges, c.parent, c.child, 0, 0), c.parent);
|
|
64409
|
+
}
|
|
64410
|
+
break;
|
|
64411
|
+
}
|
|
64412
|
+
case 'unlink': {
|
|
64413
|
+
vertex(c.parent, i);
|
|
64414
|
+
vertex(c.child, i);
|
|
64415
|
+
const before = g.edges.length;
|
|
64416
|
+
g.edges = ServiceTransform.removeEdge(g.edges, c.parent, c.child);
|
|
64417
|
+
if (g.edges.length === before) {
|
|
64418
|
+
throw new Error(`change ${i + 1}: '${c.child}' is not a direct child of '${c.parent}'`);
|
|
64419
|
+
}
|
|
64420
|
+
break;
|
|
64421
|
+
}
|
|
64422
|
+
}
|
|
64423
|
+
});
|
|
64424
|
+
return g;
|
|
64425
|
+
}
|
|
64426
|
+
ServiceBulk.applyChanges = applyChanges;
|
|
64427
|
+
/** Order-insensitive form of an attribute value, for comparison and display. */
|
|
64428
|
+
function normalize(field, value) {
|
|
64429
|
+
if (field === 'tags' && Array.isArray(value))
|
|
64430
|
+
return [...value].sort();
|
|
64431
|
+
if (field === 'customProperties' && Array.isArray(value)) {
|
|
64432
|
+
return [...value]
|
|
64433
|
+
.map((p) => ({ name: p.name, value: p.value }))
|
|
64434
|
+
.sort((x, y) => x.name.localeCompare(y.name) || x.value.localeCompare(y.value));
|
|
64435
|
+
}
|
|
64436
|
+
return value;
|
|
64437
|
+
}
|
|
64438
|
+
ServiceBulk.normalize = normalize;
|
|
64439
|
+
const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
|
|
64440
|
+
function fieldChanges(before, after) {
|
|
64441
|
+
const out = [];
|
|
64442
|
+
const keys = Object.keys(after);
|
|
64443
|
+
for (const key of keys) {
|
|
64444
|
+
if (IGNORED_FIELDS.has(key))
|
|
64445
|
+
continue;
|
|
64446
|
+
const b = before ? normalize(key, before[key]) : undefined;
|
|
64447
|
+
const a = normalize(key, after[key]);
|
|
64448
|
+
if (!same(a, b))
|
|
64449
|
+
out.push({ field: key, before: b, after: a });
|
|
64450
|
+
}
|
|
64451
|
+
return out;
|
|
64452
|
+
}
|
|
64453
|
+
/** Per-service differences between two graphs (services removed from `after` are not reported). */
|
|
64454
|
+
function diffGraphs(before, after) {
|
|
64455
|
+
const out = [];
|
|
64456
|
+
for (const name of Object.keys(after.vertices).sort()) {
|
|
64457
|
+
const b = before.vertices[name];
|
|
64458
|
+
const fields = fieldChanges(b?.attributes, after.vertices[name].attributes);
|
|
64459
|
+
const kidsBefore = childLinks(before, name);
|
|
64460
|
+
const kidsAfter = childLinks(after, name);
|
|
64461
|
+
const childrenChanged = !same(kidsBefore, kidsAfter);
|
|
64462
|
+
if (b && !fields.length && !childrenChanged)
|
|
64463
|
+
continue;
|
|
64464
|
+
out.push({
|
|
64465
|
+
service: name,
|
|
64466
|
+
status: b ? 'changed' : 'created',
|
|
64467
|
+
fields,
|
|
64468
|
+
...(childrenChanged ? { children: { before: kidsBefore, after: kidsAfter } } : {}),
|
|
64469
|
+
});
|
|
64470
|
+
}
|
|
64471
|
+
return out;
|
|
64472
|
+
}
|
|
64473
|
+
ServiceBulk.diffGraphs = diffGraphs;
|
|
64474
|
+
/**
|
|
64475
|
+
* Plan changes against a graph read for `targets`: the diff, the services the
|
|
64476
|
+
* payload must carry, and the store body.
|
|
64477
|
+
* @throws Error when a change is invalid or a parent's weights exceed 100 %.
|
|
64478
|
+
*/
|
|
64479
|
+
function planChanges(graph, targets, changes) {
|
|
64480
|
+
const after = applyChanges(graph, changes);
|
|
64481
|
+
const diff = diffGraphs(graph, after);
|
|
64482
|
+
const save = descendantClosure(after, diff.map((d) => d.service)).sort();
|
|
64483
|
+
for (const name of save) {
|
|
64484
|
+
try {
|
|
64485
|
+
ServiceTransform.assertWeightsWithinLimit(after.edges, name);
|
|
64486
|
+
}
|
|
64487
|
+
catch (e) {
|
|
64488
|
+
throw new Error(`'${name}': ${e.message}`);
|
|
64489
|
+
}
|
|
64490
|
+
}
|
|
64491
|
+
return { plan: { targets, changes, diff, save }, body: diff.length ? bodyFor(after, save) : { vertices: [], edges: [] } };
|
|
64492
|
+
}
|
|
64493
|
+
ServiceBulk.planChanges = planChanges;
|
|
64494
|
+
/**
|
|
64495
|
+
* What moved between a plan and a fresh read, limited to the values the plan
|
|
64496
|
+
* replaces: a changed field, a changed set of children, a service the plan
|
|
64497
|
+
* edits that is gone, or one it creates that now exists. Empty = safe to commit.
|
|
64498
|
+
*/
|
|
64499
|
+
function findConflicts(planned, fresh) {
|
|
64500
|
+
const conflicts = [];
|
|
64501
|
+
for (const d of planned.diff) {
|
|
64502
|
+
const now = fresh.vertices[d.service];
|
|
64503
|
+
if (d.status === 'created') {
|
|
64504
|
+
if (now)
|
|
64505
|
+
conflicts.push(`'${d.service}' was created by someone else`);
|
|
64506
|
+
continue;
|
|
64507
|
+
}
|
|
64508
|
+
if (!now) {
|
|
64509
|
+
conflicts.push(`'${d.service}' no longer exists`);
|
|
64510
|
+
continue;
|
|
64511
|
+
}
|
|
64512
|
+
for (const f of d.fields) {
|
|
64513
|
+
const current = normalize(f.field, now.attributes[f.field]);
|
|
64514
|
+
if (!same(current, f.before)) {
|
|
64515
|
+
conflicts.push(`'${d.service}' ${f.field}: planned from ${JSON.stringify(f.before)}, now ${JSON.stringify(current)}`);
|
|
64516
|
+
}
|
|
64517
|
+
}
|
|
64518
|
+
if (d.children && !same(childLinks(fresh, d.service), d.children.before)) {
|
|
64519
|
+
conflicts.push(`'${d.service}' children changed since the plan`);
|
|
64520
|
+
}
|
|
64521
|
+
}
|
|
64522
|
+
return conflicts;
|
|
64523
|
+
}
|
|
64524
|
+
ServiceBulk.findConflicts = findConflicts;
|
|
64525
|
+
})(ServiceBulk || (ServiceBulk = {}));
|
|
64526
|
+
|
|
64527
|
+
/**
|
|
64528
|
+
* Pure selection and edit expansion for `service bulk-update`: which services a
|
|
64529
|
+
* selector picks, and which concrete {@link ServiceBulk.ServiceChange}s one set of
|
|
64530
|
+
* edits produces for each — only the ones that would change something, with the
|
|
64531
|
+
* reason for every edit that would not (already tagged, text not found, …).
|
|
64532
|
+
*/
|
|
64533
|
+
var ServiceBulkSelect;
|
|
64534
|
+
(function (ServiceBulkSelect) {
|
|
64535
|
+
const names = (what) => z.array(z.string().min(1)).min(1).describe(what);
|
|
64536
|
+
ServiceBulkSelect.ServiceSelectorSchema = z
|
|
64537
|
+
.strictObject({
|
|
64538
|
+
services: names('Exactly these services (exact, case-sensitive names).').optional(),
|
|
64539
|
+
root: z
|
|
64540
|
+
.string()
|
|
64541
|
+
.min(1)
|
|
64542
|
+
.describe('This service and its descendants (exact name).')
|
|
64543
|
+
.optional(),
|
|
64544
|
+
depth: z
|
|
64545
|
+
.number()
|
|
64546
|
+
.int()
|
|
64547
|
+
.min(0)
|
|
64548
|
+
.describe('With root: 0 = root only, 1 = root and direct children, … (default: all).')
|
|
64549
|
+
.optional(),
|
|
64550
|
+
name: names('Name matches any of these globs (* and ?, case-insensitive).').optional(),
|
|
64551
|
+
hasTag: names('Has every one of these tags (exact).').optional(),
|
|
64552
|
+
lacksTag: names('Has none of these tags (exact).').optional(),
|
|
64553
|
+
hasProperty: names('Has every one of these custom properties (exact names).').optional(),
|
|
64554
|
+
lacksProperty: names('Has none of these custom properties (exact names).').optional(),
|
|
64555
|
+
where: z
|
|
64556
|
+
.record(z.string().min(1), z.string())
|
|
64557
|
+
.describe('Custom property name → glob its value must match (case-insensitive; no * = equals).')
|
|
64558
|
+
.optional(),
|
|
64559
|
+
location: z.string().describe('Location matches this glob (case-insensitive).').optional(),
|
|
64560
|
+
})
|
|
64561
|
+
.refine((s) => Object.values(s).some((v) => v !== undefined), {
|
|
64562
|
+
message: 'a selector needs at least one criterion',
|
|
64563
|
+
})
|
|
64564
|
+
.refine((s) => s.depth === undefined || s.root !== undefined, {
|
|
64565
|
+
message: 'depth needs root',
|
|
64566
|
+
})
|
|
64567
|
+
.describe('Which services to edit; every criterion given must hold (AND).');
|
|
64568
|
+
ServiceBulkSelect.BulkEditSchema = z
|
|
64569
|
+
.strictObject({
|
|
64570
|
+
addTags: names('Tags to add.').optional(),
|
|
64571
|
+
removeTags: names('Tags to remove.').optional(),
|
|
64572
|
+
setProperties: z
|
|
64573
|
+
.record(z.string().min(1), z.string())
|
|
64574
|
+
.describe('Custom properties to set (name → value); other properties are kept.')
|
|
64575
|
+
.optional(),
|
|
64576
|
+
removeProperties: names('Custom properties to remove.').optional(),
|
|
64577
|
+
replaceInProperty: z
|
|
64578
|
+
.strictObject({
|
|
64579
|
+
property: z.string().min(1).describe("Property name, or '*' for every property."),
|
|
64580
|
+
find: z.string().min(1).describe('Text to find (case-sensitive substring).'),
|
|
64581
|
+
replaceWith: z.string().describe('Replacement for every occurrence.'),
|
|
64582
|
+
})
|
|
64583
|
+
.describe('Search and replace inside custom property values.')
|
|
64584
|
+
.optional(),
|
|
64585
|
+
setLocation: z.string().describe('New location.').optional(),
|
|
64586
|
+
setDescription: z.string().describe('New description.').optional(),
|
|
64587
|
+
})
|
|
64588
|
+
.refine((e) => Object.values(e).some((v) => v !== undefined), {
|
|
64589
|
+
message: 'at least one edit is needed',
|
|
64590
|
+
})
|
|
64591
|
+
.describe('The edits applied to every selected service.');
|
|
64592
|
+
function subjectFromVertex(v) {
|
|
64593
|
+
const a = v.attributes;
|
|
64594
|
+
return { name: a.name, tags: a.tags, properties: a.customProperties, location: a.location };
|
|
64595
|
+
}
|
|
64596
|
+
ServiceBulkSelect.subjectFromVertex = subjectFromVertex;
|
|
64597
|
+
/** From a services-list row, whose custom properties are a name → value map. */
|
|
64598
|
+
function subjectFromListRow(row) {
|
|
64599
|
+
return {
|
|
64600
|
+
name: row.name,
|
|
64601
|
+
tags: row.tags ?? [],
|
|
64602
|
+
properties: Object.entries(row.customProperties ?? {}).map(([name, value]) => ({ name, value })),
|
|
64603
|
+
location: row.location ?? '',
|
|
64604
|
+
};
|
|
64605
|
+
}
|
|
64606
|
+
ServiceBulkSelect.subjectFromListRow = subjectFromListRow;
|
|
64607
|
+
/** A case-insensitive, anchored glob: `*` any run, `?` one character. */
|
|
64608
|
+
function globToRegExp(glob) {
|
|
64609
|
+
const body = glob
|
|
64610
|
+
.split('')
|
|
64611
|
+
.map((c) => (c === '*' ? '.*' : c === '?' ? '.' : c.replace(/[.+^${}()|[\]\\]/g, '\\$&')))
|
|
64612
|
+
.join('');
|
|
64613
|
+
return new RegExp(`^${body}$`, 'i');
|
|
64614
|
+
}
|
|
64615
|
+
ServiceBulkSelect.globToRegExp = globToRegExp;
|
|
64616
|
+
/** The non-scope criteria (everything but services/root/depth) against one service. */
|
|
64617
|
+
function matchesFilters(s, sel) {
|
|
64618
|
+
const has = (p) => s.properties.some((x) => x.name === p);
|
|
64619
|
+
if (sel.name && !sel.name.some((g) => globToRegExp(g).test(s.name)))
|
|
64620
|
+
return false;
|
|
64621
|
+
if (sel.hasTag && !sel.hasTag.every((t) => s.tags.includes(t)))
|
|
64622
|
+
return false;
|
|
64623
|
+
if (sel.lacksTag && sel.lacksTag.some((t) => s.tags.includes(t)))
|
|
64624
|
+
return false;
|
|
64625
|
+
if (sel.hasProperty && !sel.hasProperty.every(has))
|
|
64626
|
+
return false;
|
|
64627
|
+
if (sel.lacksProperty && sel.lacksProperty.some(has))
|
|
64628
|
+
return false;
|
|
64629
|
+
if (sel.location !== undefined && !globToRegExp(sel.location).test(s.location))
|
|
64630
|
+
return false;
|
|
64631
|
+
for (const [prop, glob] of Object.entries(sel.where ?? {})) {
|
|
64632
|
+
const re = globToRegExp(glob);
|
|
64633
|
+
if (!s.properties.some((x) => x.name === prop && re.test(x.value)))
|
|
64634
|
+
return false;
|
|
64635
|
+
}
|
|
64636
|
+
return true;
|
|
64637
|
+
}
|
|
64638
|
+
ServiceBulkSelect.matchesFilters = matchesFilters;
|
|
64639
|
+
/** The selector as one line, for messages: `name="*virt*" AND hasTag=internal`. */
|
|
64640
|
+
function describeSelector(sel) {
|
|
64641
|
+
const parts = [];
|
|
64642
|
+
const list = (xs) => xs.join(',');
|
|
64643
|
+
if (sel.services)
|
|
64644
|
+
parts.push(`services=${list(sel.services)}`);
|
|
64645
|
+
if (sel.root)
|
|
64646
|
+
parts.push(`root="${sel.root}"`);
|
|
64647
|
+
if (sel.depth !== undefined)
|
|
64648
|
+
parts.push(`depth=${sel.depth}`);
|
|
64649
|
+
if (sel.name)
|
|
64650
|
+
parts.push(`name="${list(sel.name)}"`);
|
|
64651
|
+
if (sel.hasTag)
|
|
64652
|
+
parts.push(`hasTag=${list(sel.hasTag)}`);
|
|
64653
|
+
if (sel.lacksTag)
|
|
64654
|
+
parts.push(`lacksTag=${list(sel.lacksTag)}`);
|
|
64655
|
+
if (sel.hasProperty)
|
|
64656
|
+
parts.push(`hasProperty=${list(sel.hasProperty)}`);
|
|
64657
|
+
if (sel.lacksProperty)
|
|
64658
|
+
parts.push(`lacksProperty=${list(sel.lacksProperty)}`);
|
|
64659
|
+
for (const [p, g] of Object.entries(sel.where ?? {}))
|
|
64660
|
+
parts.push(`where.${p}="${g}"`);
|
|
64661
|
+
if (sel.location !== undefined)
|
|
64662
|
+
parts.push(`location="${sel.location}"`);
|
|
64663
|
+
return parts.join(' AND ');
|
|
64664
|
+
}
|
|
64665
|
+
ServiceBulkSelect.describeSelector = describeSelector;
|
|
64666
|
+
/** `root` and its descendants down to `depth` levels (all when undefined). */
|
|
64667
|
+
function withinDepth(graph, root, depth) {
|
|
64668
|
+
const seen = new Set([root]);
|
|
64669
|
+
let frontier = [root];
|
|
64670
|
+
for (let level = 0; frontier.length && (depth === undefined || level < depth); level++) {
|
|
64671
|
+
const next = [];
|
|
64672
|
+
for (const parent of frontier) {
|
|
64673
|
+
for (const link of ServiceBulk.childLinks(graph, parent)) {
|
|
64674
|
+
if (!seen.has(link.child)) {
|
|
64675
|
+
seen.add(link.child);
|
|
64676
|
+
next.push(link.child);
|
|
64677
|
+
}
|
|
64678
|
+
}
|
|
64679
|
+
}
|
|
64680
|
+
frontier = next;
|
|
64681
|
+
}
|
|
64682
|
+
return [...seen];
|
|
64683
|
+
}
|
|
64684
|
+
ServiceBulkSelect.withinDepth = withinDepth;
|
|
64685
|
+
/** Edits that contradict each other; any entry blocks the update. */
|
|
64686
|
+
function editBlockers(e) {
|
|
64687
|
+
const out = [];
|
|
64688
|
+
for (const t of e.addTags ?? []) {
|
|
64689
|
+
if (e.removeTags?.includes(t))
|
|
64690
|
+
out.push(`tag '${t}' is both added and removed`);
|
|
64691
|
+
}
|
|
64692
|
+
for (const p of Object.keys(e.setProperties ?? {})) {
|
|
64693
|
+
if (e.removeProperties?.includes(p))
|
|
64694
|
+
out.push(`property '${p}' is both set and removed`);
|
|
64695
|
+
}
|
|
64696
|
+
const r = e.replaceInProperty;
|
|
64697
|
+
if (r) {
|
|
64698
|
+
if (r.find === r.replaceWith)
|
|
64699
|
+
out.push('find and replaceWith are the same — nothing would change');
|
|
64700
|
+
const named = r.property === '*' ? [] : [r.property];
|
|
64701
|
+
for (const p of named) {
|
|
64702
|
+
if (e.setProperties?.[p] !== undefined || e.removeProperties?.includes(p)) {
|
|
64703
|
+
out.push(`property '${p}' is both replaced and set or removed`);
|
|
64704
|
+
}
|
|
64705
|
+
}
|
|
64706
|
+
}
|
|
64707
|
+
return out;
|
|
64708
|
+
}
|
|
64709
|
+
ServiceBulkSelect.editBlockers = editBlockers;
|
|
64710
|
+
/**
|
|
64711
|
+
* Turn the edits into concrete changes for each named service, emitting a
|
|
64712
|
+
* change only where it alters the service. The services must be in the graph.
|
|
64713
|
+
*/
|
|
64714
|
+
function expandEdits(graph, services, e) {
|
|
64715
|
+
const changes = [];
|
|
64716
|
+
const outcomes = [];
|
|
64717
|
+
const warnings = [];
|
|
64718
|
+
for (const service of [...services].sort()) {
|
|
64719
|
+
const v = graph.vertices[service];
|
|
64720
|
+
if (!v)
|
|
64721
|
+
throw new Error(`No service with name '${service}' found`);
|
|
64722
|
+
const a = v.attributes;
|
|
64723
|
+
const will = [];
|
|
64724
|
+
const already = [];
|
|
64725
|
+
const values = (p) => a.customProperties.filter((x) => x.name === p).map((x) => x.value);
|
|
64726
|
+
const add = (e.addTags ?? []).filter((t) => {
|
|
64727
|
+
if (a.tags.includes(t)) {
|
|
64728
|
+
already.push(`already has tag '${t}'`);
|
|
64729
|
+
return false;
|
|
64730
|
+
}
|
|
64731
|
+
const variant = a.tags.find((x) => x.toLowerCase() === t.toLowerCase());
|
|
64732
|
+
if (variant)
|
|
64733
|
+
warnings.push(`'${service}' has tag '${variant}'; adding '${t}' as well`);
|
|
64734
|
+
return true;
|
|
64735
|
+
});
|
|
64736
|
+
if (add.length) {
|
|
64737
|
+
changes.push({ op: 'addTags', service, tags: add });
|
|
64738
|
+
will.push(`add tag ${add.map((t) => `'${t}'`).join(', ')}`);
|
|
64739
|
+
}
|
|
64740
|
+
const remove = (e.removeTags ?? []).filter((t) => {
|
|
64741
|
+
if (a.tags.includes(t))
|
|
64742
|
+
return true;
|
|
64743
|
+
already.push(`does not have tag '${t}'`);
|
|
64744
|
+
return false;
|
|
64745
|
+
});
|
|
64746
|
+
if (remove.length) {
|
|
64747
|
+
changes.push({ op: 'removeTags', service, tags: remove });
|
|
64748
|
+
will.push(`remove tag ${remove.map((t) => `'${t}'`).join(', ')}`);
|
|
64749
|
+
}
|
|
64750
|
+
for (const [name, value] of Object.entries(e.setProperties ?? {})) {
|
|
64751
|
+
const now = values(name);
|
|
64752
|
+
if (now.length === 1 && now[0] === value) {
|
|
64753
|
+
already.push(`property '${name}' is already '${value}'`);
|
|
64754
|
+
continue;
|
|
64755
|
+
}
|
|
64756
|
+
if (now.length > 1) {
|
|
64757
|
+
warnings.push(`'${service}' has ${now.length} values for property '${name}'; setting leaves one`);
|
|
64758
|
+
}
|
|
64759
|
+
changes.push({ op: 'setProperty', service, name, value });
|
|
64760
|
+
will.push(now.length ? `set '${name}': '${now.join("', '")}' → '${value}'` : `add property '${name}' = '${value}'`);
|
|
64761
|
+
}
|
|
64762
|
+
for (const name of e.removeProperties ?? []) {
|
|
64763
|
+
if (!values(name).length) {
|
|
64764
|
+
already.push(`has no property '${name}'`);
|
|
64765
|
+
continue;
|
|
64766
|
+
}
|
|
64767
|
+
changes.push({ op: 'removeProperty', service, name });
|
|
64768
|
+
will.push(`remove property '${name}'`);
|
|
64769
|
+
}
|
|
64770
|
+
const r = e.replaceInProperty;
|
|
64771
|
+
if (r) {
|
|
64772
|
+
const targets = r.property === '*' ? [...new Set(a.customProperties.map((x) => x.name))] : [r.property];
|
|
64773
|
+
let replaced = false;
|
|
64774
|
+
for (const name of targets) {
|
|
64775
|
+
const now = values(name);
|
|
64776
|
+
if (!now.some((x) => x.includes(r.find)))
|
|
64777
|
+
continue;
|
|
64778
|
+
if (now.length > 1) {
|
|
64779
|
+
warnings.push(`'${service}' has ${now.length} values for property '${name}'; not replaced`);
|
|
64780
|
+
already.push(`property '${name}' has ${now.length} values — skipped`);
|
|
64781
|
+
continue;
|
|
64782
|
+
}
|
|
64783
|
+
const value = now[0].split(r.find).join(r.replaceWith);
|
|
64784
|
+
changes.push({ op: 'setProperty', service, name, value });
|
|
64785
|
+
will.push(`set '${name}': '${now[0]}' → '${value}'`);
|
|
64786
|
+
replaced = true;
|
|
64787
|
+
}
|
|
64788
|
+
if (!replaced && !already.some((x) => x.includes('— skipped'))) {
|
|
64789
|
+
already.push(`text '${r.find}' not found in ${r.property === '*' ? 'any property' : `'${r.property}'`}`);
|
|
64790
|
+
}
|
|
64791
|
+
}
|
|
64792
|
+
const attrs = {};
|
|
64793
|
+
if (e.setLocation !== undefined) {
|
|
64794
|
+
if (a.location === e.setLocation)
|
|
64795
|
+
already.push(`location is already '${e.setLocation}'`);
|
|
64796
|
+
else {
|
|
64797
|
+
attrs.location = e.setLocation;
|
|
64798
|
+
will.push(`location: '${a.location}' → '${e.setLocation}'`);
|
|
64799
|
+
}
|
|
64800
|
+
}
|
|
64801
|
+
if (e.setDescription !== undefined) {
|
|
64802
|
+
if (a.description === e.setDescription)
|
|
64803
|
+
already.push('description is already as given');
|
|
64804
|
+
else {
|
|
64805
|
+
attrs.description = e.setDescription;
|
|
64806
|
+
will.push(`description: '${a.description}' → '${e.setDescription}'`);
|
|
64807
|
+
}
|
|
64808
|
+
}
|
|
64809
|
+
if (Object.keys(attrs).length)
|
|
64810
|
+
changes.push({ op: 'setAttributes', service, ...attrs });
|
|
64811
|
+
outcomes.push({ service, will, already });
|
|
64812
|
+
}
|
|
64813
|
+
return { changes, outcomes, warnings };
|
|
64814
|
+
}
|
|
64815
|
+
ServiceBulkSelect.expandEdits = expandEdits;
|
|
64816
|
+
/**
|
|
64817
|
+
* A short, stable hash of what a plan would save (its diff and save set). A
|
|
64818
|
+
* dry-run prints it; an apply must present it, and refuses when the fresh
|
|
64819
|
+
* plan hashes differently — so what was reviewed is what gets saved.
|
|
64820
|
+
*/
|
|
64821
|
+
function planToken(plan) {
|
|
64822
|
+
return cyrb53(JSON.stringify({ diff: plan.diff, save: plan.save }))
|
|
64823
|
+
.toString(16)
|
|
64824
|
+
.padStart(14, '0')
|
|
64825
|
+
.slice(0, 10);
|
|
64826
|
+
}
|
|
64827
|
+
ServiceBulkSelect.planToken = planToken;
|
|
64828
|
+
})(ServiceBulkSelect || (ServiceBulkSelect = {}));
|
|
64829
|
+
|
|
64830
|
+
/**
|
|
64831
|
+
* The `service export` / `service export-hierarchy` file format and the
|
|
64832
|
+
* `service import` boundary validator.
|
|
64833
|
+
*
|
|
64834
|
+
* The envelope wraps a re-postable store body ({@link CreateServices.CreateServiceBody})
|
|
64835
|
+
* with provenance metadata. `import` accepts either the envelope or a bare body.
|
|
64836
|
+
*/
|
|
64837
|
+
var ServiceExport;
|
|
64838
|
+
(function (ServiceExport) {
|
|
64839
|
+
ServiceExport.SCHEMA_VERSION = 1;
|
|
64840
|
+
// Structural guard for a store body — does not re-validate every field
|
|
64841
|
+
// (the server is the authority); just enough to reject obviously-wrong files.
|
|
64842
|
+
const BodyShape = z.looseObject({
|
|
64843
|
+
vertices: z.array(z.looseObject({ attributes: z.looseObject({ name: z.string() }) })),
|
|
64844
|
+
edges: z.array(z.looseObject({
|
|
64845
|
+
sourceExternalId: z.string(),
|
|
64846
|
+
targetExternalId: z.string(),
|
|
64847
|
+
})),
|
|
64848
|
+
});
|
|
64849
|
+
const EnvelopeShape = z.looseObject({
|
|
64850
|
+
schemaVersion: z.literal(1),
|
|
64851
|
+
kind: z.enum(['service', 'service-hierarchy']),
|
|
64852
|
+
sourceTenant: z.string().optional(),
|
|
64853
|
+
exportedAt: z.string(),
|
|
64854
|
+
body: BodyShape,
|
|
64855
|
+
});
|
|
64856
|
+
/** Wrap a store body in an export envelope. */
|
|
64857
|
+
function envelope(kind, body, sourceTenant, exportedAt) {
|
|
64858
|
+
return { schemaVersion: ServiceExport.SCHEMA_VERSION, kind, sourceTenant, exportedAt, body };
|
|
64859
|
+
}
|
|
64860
|
+
ServiceExport.envelope = envelope;
|
|
64861
|
+
/**
|
|
64862
|
+
* Validate an import file (already JSON-parsed) and return the store body.
|
|
64863
|
+
* Accepts a full export envelope or a bare `{ vertices, edges }` body.
|
|
64864
|
+
* @throws Error when the input is neither shape.
|
|
64865
|
+
*/
|
|
64866
|
+
function parseImport(raw) {
|
|
64867
|
+
const asEnvelope = EnvelopeShape.safeParse(raw);
|
|
64868
|
+
if (asEnvelope.success) {
|
|
64869
|
+
return asEnvelope.data.body;
|
|
64870
|
+
}
|
|
64871
|
+
const asBody = BodyShape.safeParse(raw);
|
|
64872
|
+
if (asBody.success) {
|
|
64873
|
+
return raw;
|
|
64874
|
+
}
|
|
64875
|
+
throw new Error('Import file is neither a service export envelope nor a bare {vertices, edges} body. ' +
|
|
64876
|
+
`Envelope error: ${asEnvelope.error.message}`);
|
|
64877
|
+
}
|
|
64878
|
+
ServiceExport.parseImport = parseImport;
|
|
64879
|
+
/**
|
|
64880
|
+
* As {@link parseImport}, plus the envelope's provenance: which tenant the file came from
|
|
64881
|
+
* (absent for a bare body or an envelope that did not record it) and when.
|
|
64882
|
+
* @throws Error when the input is neither shape.
|
|
64883
|
+
*/
|
|
64884
|
+
function parseImportFile(raw) {
|
|
64885
|
+
const body = parseImport(raw);
|
|
64886
|
+
const asEnvelope = EnvelopeShape.safeParse(raw);
|
|
64887
|
+
if (!asEnvelope.success)
|
|
64888
|
+
return { body };
|
|
64889
|
+
return {
|
|
64890
|
+
body,
|
|
64891
|
+
...(asEnvelope.data.sourceTenant ? { sourceTenant: asEnvelope.data.sourceTenant } : {}),
|
|
64892
|
+
exportedAt: asEnvelope.data.exportedAt,
|
|
64893
|
+
};
|
|
64894
|
+
}
|
|
64895
|
+
ServiceExport.parseImportFile = parseImportFile;
|
|
64896
|
+
})(ServiceExport || (ServiceExport = {}));
|
|
64897
|
+
|
|
64898
|
+
/**
|
|
64899
|
+
* Pure planning for `service import` into any tenant
|
|
64900
|
+
* (docs/internal/service-bulk-save-findings-2026-10.md → "Cross-tenant import"):
|
|
64901
|
+
*
|
|
64902
|
+
* - A service's `metrics` are tenant identity: a save carrying another tenant's (or a
|
|
64903
|
+
* re-created service's stale) metrics is stored verbatim and the server assigns none, so
|
|
64904
|
+
* health, risk and availability point at nothing. Metrics therefore always come from the
|
|
64905
|
+
* target: an existing service keeps its current ones, a new one is sent with `[]`.
|
|
64906
|
+
* - Every saved service is overwritten (attributes and child links), so an import into a
|
|
64907
|
+
* tenant that already has some of the names is a diff to review, not a blind write.
|
|
64908
|
+
*/
|
|
64909
|
+
var ServiceImport;
|
|
64910
|
+
(function (ServiceImport) {
|
|
64911
|
+
/** Prefix every service name (and link endpoint) in a body. */
|
|
64912
|
+
function renameBody(body, prefix) {
|
|
64913
|
+
const rename = (n) => `${prefix}${n}`;
|
|
64914
|
+
return {
|
|
64915
|
+
vertices: body.vertices.map((v) => ({
|
|
64916
|
+
...v,
|
|
64917
|
+
externalId: rename(v.attributes.name),
|
|
64918
|
+
attributes: { ...v.attributes, name: rename(v.attributes.name) },
|
|
64919
|
+
})),
|
|
64920
|
+
edges: body.edges.map((e) => ({
|
|
64921
|
+
...e,
|
|
64922
|
+
sourceExternalId: rename(e.sourceExternalId),
|
|
64923
|
+
targetExternalId: rename(e.targetExternalId),
|
|
64924
|
+
})),
|
|
64925
|
+
};
|
|
64926
|
+
}
|
|
64927
|
+
ServiceImport.renameBody = renameBody;
|
|
64928
|
+
/**
|
|
64929
|
+
* Plan saving `file` into a target whose current state for the same names is `target`
|
|
64930
|
+
* (missing names = new services).
|
|
64931
|
+
*/
|
|
64932
|
+
function planImport(file, target) {
|
|
64933
|
+
const blockers = [];
|
|
64934
|
+
const names = new Set(file.vertices.map((v) => v.attributes.name));
|
|
64935
|
+
const dangling = file.edges.filter((e) => !names.has(e.sourceExternalId) || !names.has(e.targetExternalId));
|
|
64936
|
+
if (dangling.length) {
|
|
64937
|
+
blockers.push(`links to services not in the file: ${dangling.map((e) => `${e.sourceExternalId}→${e.targetExternalId}`).join(', ')}`);
|
|
64938
|
+
}
|
|
64939
|
+
const metricsDropped = [];
|
|
64940
|
+
const metricsKeptFromTarget = [];
|
|
64941
|
+
const vertices = file.vertices.map((v) => {
|
|
64942
|
+
const name = v.attributes.name;
|
|
64943
|
+
const current = target.vertices[name];
|
|
64944
|
+
const fileMetrics = v.attributes.metrics ?? [];
|
|
64945
|
+
if (!current) {
|
|
64946
|
+
if (fileMetrics.length)
|
|
64947
|
+
metricsDropped.push(name);
|
|
64948
|
+
return { ...v, externalId: name, attributes: { ...v.attributes, root_service: null, metrics: [] } };
|
|
64949
|
+
}
|
|
64950
|
+
const targetMetrics = current.attributes.metrics ?? [];
|
|
64951
|
+
if (JSON.stringify(fileMetrics) !== JSON.stringify(targetMetrics))
|
|
64952
|
+
metricsKeptFromTarget.push(name);
|
|
64953
|
+
return { ...v, externalId: name, attributes: { ...v.attributes, root_service: null, metrics: targetMetrics } };
|
|
64954
|
+
});
|
|
64955
|
+
const body = { vertices, edges: file.edges };
|
|
64956
|
+
for (const parent of names) {
|
|
64957
|
+
try {
|
|
64958
|
+
ServiceTransform.assertWeightsWithinLimit(file.edges, parent);
|
|
64959
|
+
}
|
|
64960
|
+
catch (e) {
|
|
64961
|
+
blockers.push(`'${parent}': ${e.message}`);
|
|
64962
|
+
}
|
|
64963
|
+
}
|
|
64964
|
+
const after = {
|
|
64965
|
+
vertices: { ...target.vertices, ...Object.fromEntries(vertices.map((v) => [v.attributes.name, v])) },
|
|
64966
|
+
edges: [...target.edges.filter((e) => !names.has(e.sourceExternalId)), ...file.edges],
|
|
64967
|
+
};
|
|
64968
|
+
const diff = ServiceBulk.diffGraphs(target, after).filter((d) => names.has(d.service));
|
|
64969
|
+
const created = diff.filter((d) => d.status === 'created').map((d) => d.service).sort();
|
|
64970
|
+
const overwritten = diff.filter((d) => d.status === 'changed');
|
|
64971
|
+
const unchanged = [...names].filter((n) => target.vertices[n] && !overwritten.some((d) => d.service === n)).sort();
|
|
64972
|
+
return {
|
|
64973
|
+
body,
|
|
64974
|
+
created,
|
|
64975
|
+
overwritten,
|
|
64976
|
+
unchanged,
|
|
64977
|
+
metricsDropped: metricsDropped.sort(),
|
|
64978
|
+
metricsKeptFromTarget: metricsKeptFromTarget.sort(),
|
|
64979
|
+
blockers,
|
|
64980
|
+
};
|
|
64981
|
+
}
|
|
64982
|
+
ServiceImport.planImport = planImport;
|
|
64983
|
+
/** Stable short hash of what an import would change; the apply must present it when overwriting. */
|
|
64984
|
+
function importToken(plan) {
|
|
64985
|
+
return cyrb53(JSON.stringify({ created: plan.created, overwritten: plan.overwritten }))
|
|
64986
|
+
.toString(16)
|
|
64987
|
+
.padStart(14, '0')
|
|
64988
|
+
.slice(0, 10);
|
|
64989
|
+
}
|
|
64990
|
+
ServiceImport.importToken = importToken;
|
|
64991
|
+
})(ServiceImport || (ServiceImport = {}));
|
|
64992
|
+
|
|
64092
64993
|
var OIService;
|
|
64093
64994
|
(function (OIService) {
|
|
64094
64995
|
/** @internal */
|
|
@@ -66489,6 +67390,82 @@ const serviceDetailResponseBody = {
|
|
|
66489
67390
|
},
|
|
66490
67391
|
};
|
|
66491
67392
|
|
|
67393
|
+
/** How far back a listed service metric counts as published. */
|
|
67394
|
+
const SERVICE_METRIC_PRESENCE_WINDOW_MS = 30 * 86_400_000;
|
|
67395
|
+
/**
|
|
67396
|
+
* Marks each metric a service record lists with `published`: whether the metric store holds it within
|
|
67397
|
+
* {@link SERVICE_METRIC_PRESENCE_WINDOW_MS}. A service record lists `service_availability` for every service, but the
|
|
67398
|
+
* platform computes it only when the service has an `availability` metric configured (measured 2026-10-26 across 108
|
|
67399
|
+
* services: none of the 93 without one had it in 30 days; 10 of the 15 with one did), so an agent that reads the id
|
|
67400
|
+
* from the record otherwise spends calls on a metric that does not exist. `service_health` / `service_risk` were
|
|
67401
|
+
* published for all 108.
|
|
67402
|
+
*/
|
|
67403
|
+
function markServiceMetricPresence(overview, publishedIds) {
|
|
67404
|
+
const metrics = overview.attributes.metrics ?? [];
|
|
67405
|
+
const configured = metrics.find((m) => m.type === 'availability');
|
|
67406
|
+
const marked = metrics.map((m) => {
|
|
67407
|
+
if (publishedIds.has(m.id))
|
|
67408
|
+
return { ...m, published: true };
|
|
67409
|
+
const note = m.type === 'service_availability' && !configured
|
|
67410
|
+
? 'Never computed: a service publishes service_availability only when it has an availability metric configured, and this one has none. Read service_health and service_risk instead.'
|
|
67411
|
+
: m.type === 'service_availability' && configured
|
|
67412
|
+
? `Not published in the last 30 days, although an availability metric is configured (${configured.attributeName}): that metric may not be reporting.`
|
|
67413
|
+
: 'Not published in the last 30 days: there is no data under this id.';
|
|
67414
|
+
return { ...m, published: false, note };
|
|
67415
|
+
});
|
|
67416
|
+
return { ...overview, attributes: { ...overview.attributes, metrics: marked } };
|
|
67417
|
+
}
|
|
67418
|
+
// export const SERVICE_OVERVIEW_EXAMPLE: ServiceOverviewVertex = {
|
|
67419
|
+
// externalId:
|
|
67420
|
+
// 'SA:AA0725E0-0402-4320-A2B7-407025E9D673:2ee14366-6460-4606-9d5b-fbae9a4100b6',
|
|
67421
|
+
// attributes: {
|
|
67422
|
+
// type: 'saService',
|
|
67423
|
+
// name: 'ACME NetOps Salisbury DC - NetOps-O2',
|
|
67424
|
+
// state: 'ACTIVE',
|
|
67425
|
+
// root_service: ['ACME NetOps Salisbury DC - NetOps-O2'],
|
|
67426
|
+
// serviceContent: [],
|
|
67427
|
+
// tags: [],
|
|
67428
|
+
// location: '',
|
|
67429
|
+
// source: 'OI',
|
|
67430
|
+
// description: '',
|
|
67431
|
+
// createTimestamp: 1744572230371,
|
|
67432
|
+
// timestamp: 1744589912503,
|
|
67433
|
+
// maintenance: false,
|
|
67434
|
+
// situationsIncludeChildServices: false,
|
|
67435
|
+
// restrictSLOOnMaintenance: false,
|
|
67436
|
+
// serviceType: 'service',
|
|
67437
|
+
// customProperties: [],
|
|
67438
|
+
// metrics: [
|
|
67439
|
+
// {
|
|
67440
|
+
// type: 'service_risk',
|
|
67441
|
+
// sourceName: 'OI|SA|SERVICES|ALL',
|
|
67442
|
+
// attributeName: '2ee14366-6460-4606-9d5b-fbae9a4100b6:service_risk',
|
|
67443
|
+
// id: 'f.l-AE-H9B-OopMDK0B',
|
|
67444
|
+
// firstSeen: 1744571774000,
|
|
67445
|
+
// },
|
|
67446
|
+
// {
|
|
67447
|
+
// type: 'service_health',
|
|
67448
|
+
// sourceName: 'OI|SA|SERVICES|ALL',
|
|
67449
|
+
// attributeName: '2ee14366-6460-4606-9d5b-fbae9a4100b6:service_health',
|
|
67450
|
+
// id: '7Nm-AAB-H9B-kB8SIJ0B',
|
|
67451
|
+
// firstSeen: 1744571774000,
|
|
67452
|
+
// },
|
|
67453
|
+
// {
|
|
67454
|
+
// type: 'service_availability',
|
|
67455
|
+
// sourceName: 'OI|SA|SERVICES|ALL',
|
|
67456
|
+
// attributeName:
|
|
67457
|
+
// '2ee14366-6460-4606-9d5b-fbae9a4100b6:service_availability',
|
|
67458
|
+
// id: 'ddm-AAB-H9B-BCFeKK0B',
|
|
67459
|
+
// firstSeen: 1744571774000,
|
|
67460
|
+
// },
|
|
67461
|
+
// ],
|
|
67462
|
+
// customMetrics: [],
|
|
67463
|
+
// },
|
|
67464
|
+
// endTime: 7537103999999,
|
|
67465
|
+
// id: 3330,
|
|
67466
|
+
// startTime: 1744589912513,
|
|
67467
|
+
// };
|
|
67468
|
+
|
|
66492
67469
|
var SituationLifecycle;
|
|
66493
67470
|
(function (SituationLifecycle) {
|
|
66494
67471
|
})(SituationLifecycle || (SituationLifecycle = {}));
|
|
@@ -71714,7 +72691,7 @@ var weakSetHas = hasWeakSet ? WeakSet.prototype.has : null;
|
|
|
71714
72691
|
var hasWeakRef = typeof WeakRef === 'function' && WeakRef.prototype;
|
|
71715
72692
|
var weakRefDeref = hasWeakRef ? WeakRef.prototype.deref : null;
|
|
71716
72693
|
var booleanValueOf = Boolean.prototype.valueOf;
|
|
71717
|
-
var objectToString = Object.prototype.toString;
|
|
72694
|
+
var objectToString$1 = Object.prototype.toString;
|
|
71718
72695
|
var functionToString = Function.prototype.toString;
|
|
71719
72696
|
var $match = String.prototype.match;
|
|
71720
72697
|
var $slice = String.prototype.slice;
|
|
@@ -72034,7 +73011,7 @@ function has$2(obj, key) {
|
|
|
72034
73011
|
}
|
|
72035
73012
|
|
|
72036
73013
|
function toStr$2(obj) {
|
|
72037
|
-
return objectToString.call(obj);
|
|
73014
|
+
return objectToString$1.call(obj);
|
|
72038
73015
|
}
|
|
72039
73016
|
|
|
72040
73017
|
function nameOf(f) {
|
|
@@ -72615,6 +73592,23 @@ var setMaxIndex = function setMaxIndex(obj, maxIndex) {
|
|
|
72615
73592
|
overflowChannel.set(obj, maxIndex);
|
|
72616
73593
|
};
|
|
72617
73594
|
|
|
73595
|
+
// Track containers produced by a `strictMerge` conflict wrap, and their current max numeric index,
|
|
73596
|
+
// so repeated conflicts on one path append instead of nesting a new wrapper each time
|
|
73597
|
+
var conflictChannel = getSideChannel$1();
|
|
73598
|
+
|
|
73599
|
+
var markConflict = function markConflict(obj, maxIndex) {
|
|
73600
|
+
conflictChannel.set(obj, maxIndex);
|
|
73601
|
+
return obj;
|
|
73602
|
+
};
|
|
73603
|
+
|
|
73604
|
+
var isConflict = function isConflict(obj) {
|
|
73605
|
+
return conflictChannel.has(obj);
|
|
73606
|
+
};
|
|
73607
|
+
|
|
73608
|
+
var getConflictIndex = function getConflictIndex(obj) {
|
|
73609
|
+
return conflictChannel.get(obj);
|
|
73610
|
+
};
|
|
73611
|
+
|
|
72618
73612
|
var hexTable = (function () {
|
|
72619
73613
|
var array = [];
|
|
72620
73614
|
for (var i = 0; i < 256; ++i) {
|
|
@@ -72667,6 +73661,30 @@ var setProperty = function setProperty(obj, key, value) {
|
|
|
72667
73661
|
}
|
|
72668
73662
|
};
|
|
72669
73663
|
|
|
73664
|
+
var maxNumericIndex = function maxNumericIndex(obj, min) {
|
|
73665
|
+
var max = min;
|
|
73666
|
+
var keys = Object.keys(obj);
|
|
73667
|
+
for (var i = 0; i < keys.length; ++i) {
|
|
73668
|
+
var num = parseInt(keys[i], 10);
|
|
73669
|
+
if (String(num) === keys[i] && num > max) {
|
|
73670
|
+
max = num;
|
|
73671
|
+
}
|
|
73672
|
+
}
|
|
73673
|
+
|
|
73674
|
+
return max;
|
|
73675
|
+
};
|
|
73676
|
+
|
|
73677
|
+
var limitedPair = function limitedPair(first, second, options) {
|
|
73678
|
+
var pair = [first, second];
|
|
73679
|
+
if (options && typeof options.arrayLimit === 'number' && pair.length > options.arrayLimit) {
|
|
73680
|
+
if (options.throwOnLimitExceeded) {
|
|
73681
|
+
throw new RangeError('Array limit exceeded. Only ' + options.arrayLimit + ' element' + (options.arrayLimit === 1 ? '' : 's') + ' allowed in an array.');
|
|
73682
|
+
}
|
|
73683
|
+
return markOverflow(arrayToObject(pair, options), 1);
|
|
73684
|
+
}
|
|
73685
|
+
return pair;
|
|
73686
|
+
};
|
|
73687
|
+
|
|
72670
73688
|
var merge = function merge(target, source, options) {
|
|
72671
73689
|
/* eslint no-param-reassign: 0 */
|
|
72672
73690
|
if (!source) {
|
|
@@ -72689,8 +73707,20 @@ var merge = function merge(target, source, options) {
|
|
|
72689
73707
|
var newIndex = getMaxIndex(target) + 1;
|
|
72690
73708
|
target[newIndex] = source;
|
|
72691
73709
|
setMaxIndex(target, newIndex);
|
|
73710
|
+
} else if (options && options.strictMerge && isConflict(target)) {
|
|
73711
|
+
var nextConflict = getConflictIndex(target) + 1;
|
|
73712
|
+
if (
|
|
73713
|
+
options.throwOnLimitExceeded
|
|
73714
|
+
&& typeof options.arrayLimit === 'number'
|
|
73715
|
+
&& nextConflict >= options.arrayLimit
|
|
73716
|
+
) {
|
|
73717
|
+
throw new RangeError('Array limit exceeded. Only ' + options.arrayLimit + ' element' + (options.arrayLimit === 1 ? '' : 's') + ' allowed in an array.');
|
|
73718
|
+
}
|
|
73719
|
+
target[nextConflict] = source;
|
|
73720
|
+
markConflict(target, nextConflict);
|
|
72692
73721
|
} else if (options && options.strictMerge) {
|
|
72693
|
-
|
|
73722
|
+
var conflict = limitedPair(target, source, options);
|
|
73723
|
+
return isArray$1(conflict) ? markConflict(conflict, 1) : conflict;
|
|
72694
73724
|
} else if (
|
|
72695
73725
|
(options && (options.plainObjects || options.allowPrototypes))
|
|
72696
73726
|
|| !has$1.call(Object.prototype, source)
|
|
@@ -72698,7 +73728,7 @@ var merge = function merge(target, source, options) {
|
|
|
72698
73728
|
target[source] = true;
|
|
72699
73729
|
}
|
|
72700
73730
|
} else {
|
|
72701
|
-
return
|
|
73731
|
+
return limitedPair(target, source, options);
|
|
72702
73732
|
}
|
|
72703
73733
|
|
|
72704
73734
|
return target;
|
|
@@ -72730,6 +73760,10 @@ var merge = function merge(target, source, options) {
|
|
|
72730
73760
|
var mergeTarget = target;
|
|
72731
73761
|
if (isArray$1(target) && !isArray$1(source)) {
|
|
72732
73762
|
mergeTarget = arrayToObject(target, options);
|
|
73763
|
+
if (isConflict(target)) {
|
|
73764
|
+
// the array may have grown past its last conflict, so continue after its last index
|
|
73765
|
+
markConflict(mergeTarget, target.length - 1);
|
|
73766
|
+
}
|
|
72733
73767
|
}
|
|
72734
73768
|
|
|
72735
73769
|
if (isArray$1(target) && isArray$1(source)) {
|
|
@@ -72764,7 +73798,7 @@ var merge = function merge(target, source, options) {
|
|
|
72764
73798
|
}
|
|
72765
73799
|
|
|
72766
73800
|
if (isOverflow(source) && !isOverflow(acc)) {
|
|
72767
|
-
markOverflow(acc, getMaxIndex(source));
|
|
73801
|
+
markOverflow(acc, maxNumericIndex(acc, getMaxIndex(source)));
|
|
72768
73802
|
}
|
|
72769
73803
|
if (isOverflow(acc)) {
|
|
72770
73804
|
var keyNum = parseInt(key, 10);
|
|
@@ -72772,6 +73806,12 @@ var merge = function merge(target, source, options) {
|
|
|
72772
73806
|
setMaxIndex(acc, keyNum);
|
|
72773
73807
|
}
|
|
72774
73808
|
}
|
|
73809
|
+
if (isConflict(acc)) {
|
|
73810
|
+
var conflictKey = parseInt(key, 10);
|
|
73811
|
+
if (String(conflictKey) === key && conflictKey > getConflictIndex(acc)) {
|
|
73812
|
+
markConflict(acc, conflictKey);
|
|
73813
|
+
}
|
|
73814
|
+
}
|
|
72775
73815
|
|
|
72776
73816
|
return acc;
|
|
72777
73817
|
}, mergeTarget);
|
|
@@ -72785,6 +73825,13 @@ var assign = function assignSingleSource(target, source) {
|
|
|
72785
73825
|
};
|
|
72786
73826
|
|
|
72787
73827
|
var decode = function (str, defaultDecoder, charset) {
|
|
73828
|
+
// With no `%` there is no escape to expand, in either charset: `unescape` has
|
|
73829
|
+
// nothing to match, and `decodeURIComponent` is the identity on such a string
|
|
73830
|
+
// (and cannot throw). So only `+` -> ' ' remains, and often not even that.
|
|
73831
|
+
if (typeof str === 'string' && str.indexOf('%') === -1) {
|
|
73832
|
+
return str.indexOf('+') === -1 ? str : str.replace(/\+/g, ' ');
|
|
73833
|
+
}
|
|
73834
|
+
|
|
72788
73835
|
var strWithoutPlus = str.replace(/\+/g, ' ');
|
|
72789
73836
|
if (charset === 'iso-8859-1') {
|
|
72790
73837
|
// unescape never throws, no try...catch needed:
|
|
@@ -72798,6 +73845,57 @@ var decode = function (str, defaultDecoder, charset) {
|
|
|
72798
73845
|
}
|
|
72799
73846
|
};
|
|
72800
73847
|
|
|
73848
|
+
var hasToPrimitive = typeof Symbol === 'function' && typeof Symbol.toPrimitive === 'symbol';
|
|
73849
|
+
var arrayJoin = Array.prototype.join;
|
|
73850
|
+
var arrayToString = Array.prototype.toString;
|
|
73851
|
+
var objectToString = Object.prototype.toString;
|
|
73852
|
+
|
|
73853
|
+
// an object with no callable toString (eg, from JSON, or null-prototype) would make String() or join() throw,
|
|
73854
|
+
// so it becomes its primitive valueOf or else Object.prototype.toString; arrays are walked like join walks them,
|
|
73855
|
+
// copied only once an element changes, with an array already being joined becoming '' as engines do for cycles
|
|
73856
|
+
var toCoercible = function toCoercible(value, joining) {
|
|
73857
|
+
if (!value || (typeof value !== 'object' && typeof value !== 'function')) {
|
|
73858
|
+
return value;
|
|
73859
|
+
}
|
|
73860
|
+
if (hasToPrimitive && value[Symbol.toPrimitive] != null) {
|
|
73861
|
+
return value;
|
|
73862
|
+
}
|
|
73863
|
+
if (isArray$1(value) && value.toString === arrayToString && value.join === arrayJoin) {
|
|
73864
|
+
var ancestors = joining || getSideChannel$1();
|
|
73865
|
+
if (ancestors.has(value)) {
|
|
73866
|
+
return '';
|
|
73867
|
+
}
|
|
73868
|
+
ancestors.set(value, true);
|
|
73869
|
+
var copy;
|
|
73870
|
+
for (var i = 0; i < value.length; i += 1) {
|
|
73871
|
+
var item = value[i];
|
|
73872
|
+
var coerced = toCoercible(item, ancestors);
|
|
73873
|
+
if (!copy && coerced !== item) {
|
|
73874
|
+
copy = [];
|
|
73875
|
+
for (var j = 0; j < i; j += 1) {
|
|
73876
|
+
copy[j] = value[j];
|
|
73877
|
+
}
|
|
73878
|
+
}
|
|
73879
|
+
if (copy) {
|
|
73880
|
+
copy[i] = coerced;
|
|
73881
|
+
}
|
|
73882
|
+
}
|
|
73883
|
+
ancestors['delete'](value);
|
|
73884
|
+
return copy || value;
|
|
73885
|
+
}
|
|
73886
|
+
if (typeof value.toString === 'function') {
|
|
73887
|
+
return value;
|
|
73888
|
+
}
|
|
73889
|
+
var valueOf = value.valueOf;
|
|
73890
|
+
if (typeof valueOf === 'function') {
|
|
73891
|
+
var primitive = valueOf.call(value);
|
|
73892
|
+
if (!primitive || (typeof primitive !== 'object' && typeof primitive !== 'function')) {
|
|
73893
|
+
return String(primitive);
|
|
73894
|
+
}
|
|
73895
|
+
}
|
|
73896
|
+
return objectToString.call(value);
|
|
73897
|
+
};
|
|
73898
|
+
|
|
72801
73899
|
var limit = 1024;
|
|
72802
73900
|
|
|
72803
73901
|
/* eslint operator-linebreak: [2, "before"] */
|
|
@@ -72813,13 +73911,15 @@ var encode = function encode(str, defaultEncoder, charset, kind, format) {
|
|
|
72813
73911
|
if (typeof str === 'symbol') {
|
|
72814
73912
|
string = Symbol.prototype.toString.call(str);
|
|
72815
73913
|
} else if (typeof str !== 'string') {
|
|
72816
|
-
string = String(str);
|
|
73914
|
+
string = String(toCoercible(str));
|
|
72817
73915
|
}
|
|
72818
73916
|
|
|
72819
73917
|
if (charset === 'iso-8859-1') {
|
|
73918
|
+
// `escape` leaves `+` untouched, but a literal `+` is decoded back to a space,
|
|
73919
|
+
// so it must be percent-encoded to round-trip (the utf-8 path already does this).
|
|
72820
73920
|
return escape(string).replace(/%u[0-9a-f]{4}/gi, function ($0) {
|
|
72821
73921
|
return '%26%23' + parseInt($0.slice(2), 16) + '%3B';
|
|
72822
|
-
});
|
|
73922
|
+
}).replace(/\+/g, '%2B');
|
|
72823
73923
|
}
|
|
72824
73924
|
|
|
72825
73925
|
var out = '';
|
|
@@ -72971,7 +74071,8 @@ var utils$1 = {
|
|
|
72971
74071
|
isRegExp: isRegExp,
|
|
72972
74072
|
markOverflow: markOverflow,
|
|
72973
74073
|
maybeMap: maybeMap,
|
|
72974
|
-
merge: merge
|
|
74074
|
+
merge: merge,
|
|
74075
|
+
toCoercible: toCoercible
|
|
72975
74076
|
};
|
|
72976
74077
|
|
|
72977
74078
|
var getSideChannel = sideChannel;
|
|
@@ -73124,10 +74225,10 @@ var stringify$2 = function stringify(
|
|
|
73124
74225
|
// we need to join elements in
|
|
73125
74226
|
if (encodeValuesOnly && encoder) {
|
|
73126
74227
|
obj = utils.maybeMap(obj, function (v) {
|
|
73127
|
-
return v == null ? v : encoder(v);
|
|
74228
|
+
return v == null ? v : encoder(v, defaults.encoder, charset, 'value', format);
|
|
73128
74229
|
});
|
|
73129
74230
|
}
|
|
73130
|
-
objKeys = [{ value: obj.length > 0 ? obj.join(',') || null : void undefined }];
|
|
74231
|
+
objKeys = [{ value: obj.length > 0 ? utils.toCoercible(obj).join(',') || null : void undefined }];
|
|
73131
74232
|
} else if (isArray(filter)) {
|
|
73132
74233
|
objKeys = filter;
|
|
73133
74234
|
} else {
|
|
@@ -73135,7 +74236,7 @@ var stringify$2 = function stringify(
|
|
|
73135
74236
|
objKeys = sort ? keys.sort(sort) : keys;
|
|
73136
74237
|
}
|
|
73137
74238
|
|
|
73138
|
-
var encodedPrefix =
|
|
74239
|
+
var encodedPrefix = String(prefix);
|
|
73139
74240
|
|
|
73140
74241
|
var adjustedPrefix = commaRoundTrip && isArray(obj) && obj.length === 1 ? encodedPrefix + '[]' : encodedPrefix;
|
|
73141
74242
|
|
|
@@ -73225,7 +74326,7 @@ var normalizeStringifyOptions = function normalizeStringifyOptions(opts) {
|
|
|
73225
74326
|
}
|
|
73226
74327
|
|
|
73227
74328
|
var arrayFormat;
|
|
73228
|
-
if (opts.arrayFormat
|
|
74329
|
+
if (has.call(arrayPrefixGenerators, opts.arrayFormat)) {
|
|
73229
74330
|
arrayFormat = opts.arrayFormat;
|
|
73230
74331
|
} else if ('indices' in opts) {
|
|
73231
74332
|
arrayFormat = opts.indices ? 'indices' : 'repeat';
|
|
@@ -83470,6 +84571,92 @@ chain.gen = gen;
|
|
|
83470
84571
|
chain.fun = fun;
|
|
83471
84572
|
chain.dataSource = dataSource;
|
|
83472
84573
|
|
|
84574
|
+
// @ts-self-types="./path-matcher.d.ts"
|
|
84575
|
+
|
|
84576
|
+
const DIVERGED = -1,
|
|
84577
|
+
MATCHED = -2;
|
|
84578
|
+
|
|
84579
|
+
const defaultFilter$1 = () => true;
|
|
84580
|
+
|
|
84581
|
+
// Array.prototype.join semantics
|
|
84582
|
+
const toPart = key => (key == null ? '' : '' + key);
|
|
84583
|
+
|
|
84584
|
+
class PathMatcher {
|
|
84585
|
+
constructor(filter, separator = '.') {
|
|
84586
|
+
this.filter = filter;
|
|
84587
|
+
this.separator = separator;
|
|
84588
|
+
this.stateful = true;
|
|
84589
|
+
if (typeof filter == 'string') {
|
|
84590
|
+
this.filterWithSeparator = filter + separator;
|
|
84591
|
+
this.states = [0];
|
|
84592
|
+
return;
|
|
84593
|
+
}
|
|
84594
|
+
if (filter instanceof RegExp) {
|
|
84595
|
+
this.paths = [''];
|
|
84596
|
+
this.extend = this._extendRegExp;
|
|
84597
|
+
this.test = this._testRegExp;
|
|
84598
|
+
this.testRecorded = this._testRecordedRegExp;
|
|
84599
|
+
return;
|
|
84600
|
+
}
|
|
84601
|
+
this.stateful = false;
|
|
84602
|
+
this.extend = this._extendNothing;
|
|
84603
|
+
this.test = this.testRecorded = typeof filter == 'function' ? filter : defaultFilter$1;
|
|
84604
|
+
}
|
|
84605
|
+
|
|
84606
|
+
extend(stack) {
|
|
84607
|
+
const length = stack.length;
|
|
84608
|
+
if (length) this.states[length] = this._step(this.states[length - 1], stack[length - 1], length === 1);
|
|
84609
|
+
}
|
|
84610
|
+
|
|
84611
|
+
test(stack, _chunk) {
|
|
84612
|
+
const length = stack.length;
|
|
84613
|
+
return this._isMatch(length ? this._step(this.states[length - 1], stack[length - 1], length === 1) : 0);
|
|
84614
|
+
}
|
|
84615
|
+
|
|
84616
|
+
testRecorded(stack) {
|
|
84617
|
+
return this._isMatch(this.states[stack.length]);
|
|
84618
|
+
}
|
|
84619
|
+
|
|
84620
|
+
_isMatch(state) {
|
|
84621
|
+
return state === MATCHED || state === this.filter.length;
|
|
84622
|
+
}
|
|
84623
|
+
|
|
84624
|
+
// state: a position when the path is a proper prefix of filter + separator
|
|
84625
|
+
_step(state, key, isRoot) {
|
|
84626
|
+
if (!isRoot) state = this._append(state, this.separator);
|
|
84627
|
+
return this._append(state, toPart(key));
|
|
84628
|
+
}
|
|
84629
|
+
|
|
84630
|
+
_append(state, part) {
|
|
84631
|
+
if (state < 0) return state;
|
|
84632
|
+
const filterWithSeparator = this.filterWithSeparator;
|
|
84633
|
+
if (part.length < filterWithSeparator.length - state) return filterWithSeparator.startsWith(part, state) ? state + part.length : DIVERGED;
|
|
84634
|
+
return part.startsWith(filterWithSeparator.slice(state)) ? MATCHED : DIVERGED;
|
|
84635
|
+
}
|
|
84636
|
+
|
|
84637
|
+
_extendRegExp(stack) {
|
|
84638
|
+
const length = stack.length;
|
|
84639
|
+
// kept flat: a test against a concatenated parent costs ~34x more at depth 1000 (nano-bench)
|
|
84640
|
+
if (length) this.paths[length] = length === 1 ? toPart(stack[0]) : [this.paths[length - 1], this.separator, toPart(stack[length - 1])].join('');
|
|
84641
|
+
}
|
|
84642
|
+
|
|
84643
|
+
_testRegExp(stack, _chunk) {
|
|
84644
|
+
const length = stack.length,
|
|
84645
|
+
filter = this.filter;
|
|
84646
|
+
filter.lastIndex = 0;
|
|
84647
|
+
if (!length) return filter.test('');
|
|
84648
|
+
return filter.test(length === 1 ? toPart(stack[0]) : this.paths[length - 1] + this.separator + toPart(stack[length - 1]));
|
|
84649
|
+
}
|
|
84650
|
+
|
|
84651
|
+
_testRecordedRegExp(stack) {
|
|
84652
|
+
const filter = this.filter;
|
|
84653
|
+
filter.lastIndex = 0;
|
|
84654
|
+
return filter.test(this.paths[stack.length]);
|
|
84655
|
+
}
|
|
84656
|
+
|
|
84657
|
+
_extendNothing(_stack) {}
|
|
84658
|
+
}
|
|
84659
|
+
|
|
83473
84660
|
// @ts-self-types="./filter-base.d.ts"
|
|
83474
84661
|
|
|
83475
84662
|
|
|
@@ -83496,21 +84683,6 @@ const defaultFilter = () => true;
|
|
|
83496
84683
|
|
|
83497
84684
|
const DEFAULT_MAX_DEPTH = 1024;
|
|
83498
84685
|
|
|
83499
|
-
const stringFilter = (string, separator) => {
|
|
83500
|
-
const stringWithSeparator = string + separator;
|
|
83501
|
-
return stack => {
|
|
83502
|
-
const path = stack.join(separator);
|
|
83503
|
-
return path === string || path.startsWith(stringWithSeparator);
|
|
83504
|
-
};
|
|
83505
|
-
};
|
|
83506
|
-
|
|
83507
|
-
const regExpFilter = (regExp, separator) => {
|
|
83508
|
-
return stack => {
|
|
83509
|
-
regExp.lastIndex = 0;
|
|
83510
|
-
return regExp.test(stack.join(separator));
|
|
83511
|
-
};
|
|
83512
|
-
};
|
|
83513
|
-
|
|
83514
84686
|
/** @type {any} */
|
|
83515
84687
|
const filterBase =
|
|
83516
84688
|
(
|
|
@@ -83525,17 +84697,14 @@ const filterBase =
|
|
|
83525
84697
|
const once = options?.once,
|
|
83526
84698
|
separator = options?.pathSeparator || '.',
|
|
83527
84699
|
maxDepth = options?.maxDepth ?? DEFAULT_MAX_DEPTH;
|
|
83528
|
-
|
|
84700
|
+
// the filter as authored: a string or a RegExp is matched by PathMatcher, never called
|
|
84701
|
+
/** @type {((stack: any[], chunk?: any) => boolean) | string | RegExp} */
|
|
83529
84702
|
let filter = defaultFilter;
|
|
83530
84703
|
let streamKeys = false,
|
|
83531
84704
|
mirrorStreamKeys = true;
|
|
83532
84705
|
if (options) {
|
|
83533
|
-
if (typeof options.filter == 'function') {
|
|
84706
|
+
if (typeof options.filter == 'function' || typeof options.filter == 'string' || options.filter instanceof RegExp) {
|
|
83534
84707
|
filter = options.filter;
|
|
83535
|
-
} else if (typeof options.filter == 'string') {
|
|
83536
|
-
filter = stringFilter(options.filter, separator);
|
|
83537
|
-
} else if (options.filter instanceof RegExp) {
|
|
83538
|
-
filter = regExpFilter(options.filter, separator);
|
|
83539
84708
|
}
|
|
83540
84709
|
if ('streamValues' in options) {
|
|
83541
84710
|
streamKeys = options.streamValues;
|
|
@@ -83546,7 +84715,8 @@ const filterBase =
|
|
|
83546
84715
|
mirrorStreamKeys = false;
|
|
83547
84716
|
}
|
|
83548
84717
|
}
|
|
83549
|
-
const sanitizedOptions = {...options, filter, streamKeys, separator}
|
|
84718
|
+
const sanitizedOptions = {...options, filter, streamKeys, separator},
|
|
84719
|
+
matcher = new PathMatcher(options?.filter, separator);
|
|
83550
84720
|
let state = 'check',
|
|
83551
84721
|
stack = [],
|
|
83552
84722
|
depth = 0,
|
|
@@ -83675,7 +84845,7 @@ const filterBase =
|
|
|
83675
84845
|
let action = nonCheckableAction;
|
|
83676
84846
|
if (checkableTokens[chunk.name] === 1) {
|
|
83677
84847
|
if (stack.length > maxDepth) throw new RangeError(`filter: JSON nesting depth exceeds maxDepth (${maxDepth})`);
|
|
83678
|
-
action =
|
|
84848
|
+
action = matcher.test(stack, chunk) ? specialAction : defaultAction;
|
|
83679
84849
|
}
|
|
83680
84850
|
|
|
83681
84851
|
endToken = stopTokens[chunk.name] || '';
|
|
@@ -83724,9 +84894,11 @@ const filterBase =
|
|
|
83724
84894
|
// update the stack
|
|
83725
84895
|
switch (chunk.name) {
|
|
83726
84896
|
case 'startObject':
|
|
84897
|
+
matcher.extend(stack);
|
|
83727
84898
|
stack.push(null);
|
|
83728
84899
|
break;
|
|
83729
84900
|
case 'startArray':
|
|
84901
|
+
matcher.extend(stack);
|
|
83730
84902
|
stack.push(-1);
|
|
83731
84903
|
break;
|
|
83732
84904
|
case 'endObject':
|
|
@@ -87945,36 +89117,206 @@ class ServiceService {
|
|
|
87945
89117
|
return this.dxSaaSService.oiPost('oi/v2/sa/saTopologyGraph', { serviceName, startTime: Date.now(), endTime: Date.now() });
|
|
87946
89118
|
}
|
|
87947
89119
|
/**
|
|
87948
|
-
* Builds a faithful, re-postable store body for a service's entire subtree
|
|
87949
|
-
*
|
|
87950
|
-
*
|
|
87951
|
-
* `export-hierarchy`, `associate`, and `dissociate`.
|
|
89120
|
+
* Builds a faithful, re-postable store body for a service's entire subtree
|
|
89121
|
+
* (full attributes + association edges) from one hierarchy read. Shared by
|
|
89122
|
+
* `export-hierarchy`, `associate`, `dissociate` and `update-service`.
|
|
87952
89123
|
*
|
|
87953
|
-
* @
|
|
87954
|
-
* are not throttled like saves.
|
|
89124
|
+
* @throws Error if the service does not exist.
|
|
87955
89125
|
*/
|
|
87956
89126
|
async buildHierarchyBody(rootName) {
|
|
87957
|
-
const
|
|
87958
|
-
|
|
87959
|
-
|
|
87960
|
-
|
|
87961
|
-
|
|
89127
|
+
const graph = await this.readServiceGraph([rootName]);
|
|
89128
|
+
return ServiceBulk.subtreeBody(graph, rootName);
|
|
89129
|
+
}
|
|
89130
|
+
/**
|
|
89131
|
+
* Reads every hierarchy that contains the named services into one name-keyed
|
|
89132
|
+
* graph: one `GET oi/v2/sa/services/{name}?subservices=true` per service not
|
|
89133
|
+
* already covered by an earlier read (the endpoint returns whole hierarchies
|
|
89134
|
+
* from their top-level services down, full attributes included).
|
|
89135
|
+
*
|
|
89136
|
+
* @param opts.allowMissing - skip services that do not exist instead of throwing.
|
|
89137
|
+
* @throws Error if a service does not exist, or a read is paged.
|
|
89138
|
+
*/
|
|
89139
|
+
async readServiceGraph(names, opts = {}) {
|
|
89140
|
+
let graph = { vertices: {}, edges: [] };
|
|
87962
89141
|
for (const name of names) {
|
|
87963
|
-
|
|
87964
|
-
|
|
87965
|
-
|
|
87966
|
-
|
|
87967
|
-
|
|
89142
|
+
if (graph.vertices[name])
|
|
89143
|
+
continue;
|
|
89144
|
+
let read;
|
|
89145
|
+
try {
|
|
89146
|
+
read = await this.getService(name, true);
|
|
89147
|
+
}
|
|
89148
|
+
catch (e) {
|
|
89149
|
+
if (e.httpCode !== 404)
|
|
89150
|
+
throw e;
|
|
89151
|
+
if (opts.allowMissing)
|
|
89152
|
+
continue;
|
|
89153
|
+
throw new Error(`No service with name '${name}' found`);
|
|
87968
89154
|
}
|
|
89155
|
+
graph = ServiceBulk.mergeGraphs(graph, ServiceBulk.graphFromRead(read));
|
|
87969
89156
|
}
|
|
87970
|
-
|
|
87971
|
-
|
|
87972
|
-
|
|
87973
|
-
|
|
87974
|
-
|
|
87975
|
-
|
|
87976
|
-
|
|
87977
|
-
|
|
89157
|
+
return graph;
|
|
89158
|
+
}
|
|
89159
|
+
/**
|
|
89160
|
+
* Plans changes to any number of services, in any hierarchies, without
|
|
89161
|
+
* saving: reads what the changes name, applies them, and returns the
|
|
89162
|
+
* per-service diff, the services the save would carry, and the store body.
|
|
89163
|
+
*
|
|
89164
|
+
* @throws ZodError for malformed changes; Error for an invalid change or
|
|
89165
|
+
* weights over 100 %.
|
|
89166
|
+
*/
|
|
89167
|
+
async planServiceChanges(changes) {
|
|
89168
|
+
const parsed = ServiceBulk.parseChanges(changes);
|
|
89169
|
+
const targets = ServiceBulk.targetsOf(parsed);
|
|
89170
|
+
const graph = await this.readServiceGraph(targets);
|
|
89171
|
+
return ServiceBulk.planChanges(graph, targets, parsed);
|
|
89172
|
+
}
|
|
89173
|
+
/**
|
|
89174
|
+
* Previews one set of edits applied to every service a selector picks, saving
|
|
89175
|
+
* nothing. Candidates come from `services` / `root` when given, otherwise from
|
|
89176
|
+
* the services list; every criterion is then re-checked against the fresh
|
|
89177
|
+
* hierarchy read the save would be built from. Edits that would change
|
|
89178
|
+
* nothing on a service are reported, not emitted.
|
|
89179
|
+
*
|
|
89180
|
+
* @param opts.max - more services to change than this is a blocker (default 25).
|
|
89181
|
+
* @throws ZodError for a malformed selector or edits; Error when nothing matches
|
|
89182
|
+
* or a named service does not exist.
|
|
89183
|
+
*/
|
|
89184
|
+
async planBulkUpdate(selector, edits, opts = {}) {
|
|
89185
|
+
const sel = ServiceBulkSelect.ServiceSelectorSchema.parse(selector);
|
|
89186
|
+
const edit = ServiceBulkSelect.BulkEditSchema.parse(edits);
|
|
89187
|
+
const max = opts.max ?? 25;
|
|
89188
|
+
let graph = { vertices: {}, edges: [] };
|
|
89189
|
+
let candidates;
|
|
89190
|
+
if (sel.services) {
|
|
89191
|
+
graph = await this.readServiceGraph(sel.services, { allowMissing: true });
|
|
89192
|
+
const missing = sel.services.filter((n) => !graph.vertices[n]);
|
|
89193
|
+
if (missing.length)
|
|
89194
|
+
throw new Error(await this.unknownServicesMessage(missing));
|
|
89195
|
+
candidates = [...new Set(sel.services)];
|
|
89196
|
+
}
|
|
89197
|
+
if (sel.root) {
|
|
89198
|
+
graph = ServiceBulk.mergeGraphs(graph, await this.readServiceGraph([sel.root]));
|
|
89199
|
+
const scope = ServiceBulkSelect.withinDepth(graph, sel.root, sel.depth);
|
|
89200
|
+
candidates = candidates ? candidates.filter((n) => scope.includes(n)) : scope;
|
|
89201
|
+
}
|
|
89202
|
+
let checked = candidates?.length ?? 0;
|
|
89203
|
+
if (!candidates) {
|
|
89204
|
+
const rows = await this.getAllServices(100);
|
|
89205
|
+
checked = rows.length;
|
|
89206
|
+
candidates = rows
|
|
89207
|
+
.filter((r) => ServiceBulkSelect.matchesFilters(ServiceBulkSelect.subjectFromListRow(r), sel))
|
|
89208
|
+
.map((r) => r.name);
|
|
89209
|
+
graph = await this.readServiceGraph(candidates, { allowMissing: true });
|
|
89210
|
+
}
|
|
89211
|
+
const excluded = [];
|
|
89212
|
+
const matched = candidates.filter((name) => {
|
|
89213
|
+
const v = graph.vertices[name];
|
|
89214
|
+
if (!v) {
|
|
89215
|
+
excluded.push({ service: name, reason: 'no longer exists' });
|
|
89216
|
+
return false;
|
|
89217
|
+
}
|
|
89218
|
+
if (ServiceBulkSelect.matchesFilters(ServiceBulkSelect.subjectFromVertex(v), sel))
|
|
89219
|
+
return true;
|
|
89220
|
+
if (sel.services) {
|
|
89221
|
+
excluded.push({ service: name, reason: 'does not match the other criteria' });
|
|
89222
|
+
}
|
|
89223
|
+
else if (!sel.root) {
|
|
89224
|
+
excluded.push({ service: name, reason: 'no longer matches' });
|
|
89225
|
+
}
|
|
89226
|
+
return false;
|
|
89227
|
+
});
|
|
89228
|
+
if (!matched.length) {
|
|
89229
|
+
throw new Error(`0 of ${checked} services match ${ServiceBulkSelect.describeSelector(sel)}`);
|
|
89230
|
+
}
|
|
89231
|
+
const { changes, outcomes, warnings } = ServiceBulkSelect.expandEdits(graph, matched, edit);
|
|
89232
|
+
const blockers = ServiceBulkSelect.editBlockers(edit);
|
|
89233
|
+
const changing = outcomes.filter((o) => o.will.length).length;
|
|
89234
|
+
if (changing > max) {
|
|
89235
|
+
blockers.push(`${changing} services would change, more than max=${max}; narrow the selector or raise max`);
|
|
89236
|
+
}
|
|
89237
|
+
const planned = changes.length
|
|
89238
|
+
? ServiceBulk.planChanges(graph, ServiceBulk.targetsOf(changes), changes).plan
|
|
89239
|
+
: { targets: [], changes: [], diff: [], save: [] };
|
|
89240
|
+
const changed = new Set(planned.diff.map((d) => d.service));
|
|
89241
|
+
return {
|
|
89242
|
+
selector: ServiceBulkSelect.describeSelector(sel),
|
|
89243
|
+
checked,
|
|
89244
|
+
matched,
|
|
89245
|
+
outcomes,
|
|
89246
|
+
excluded,
|
|
89247
|
+
warnings,
|
|
89248
|
+
blockers,
|
|
89249
|
+
plan: planned,
|
|
89250
|
+
before: planned.save.length ? ServiceBulk.bodyFor(graph, planned.save) : { vertices: [], edges: [] },
|
|
89251
|
+
carried: planned.save.filter((n) => !changed.has(n)),
|
|
89252
|
+
confirm: ServiceBulkSelect.planToken(planned),
|
|
89253
|
+
};
|
|
89254
|
+
}
|
|
89255
|
+
/** "No service named …", with case-insensitive suggestions from the services list. */
|
|
89256
|
+
async unknownServicesMessage(missing) {
|
|
89257
|
+
const all = (await this.getAllServices(100)).map((s) => s.name);
|
|
89258
|
+
const lines = missing.map((m) => {
|
|
89259
|
+
const near = all.filter((n) => n.toLowerCase() === m.toLowerCase());
|
|
89260
|
+
return near.length ? `'${m}' (did you mean '${near.join("', '")}'?)` : `'${m}'`;
|
|
89261
|
+
});
|
|
89262
|
+
return `No service with name ${lines.join(', ')} found (names are case-sensitive)`;
|
|
89263
|
+
}
|
|
89264
|
+
/**
|
|
89265
|
+
* The tenant's service cap and how many services count against it
|
|
89266
|
+
* (`GET oi/v2/sa/serviceLimitExceeded`).
|
|
89267
|
+
*
|
|
89268
|
+
* @remarks `limitExceeded` is already true when the count equals the limit (the tenant is
|
|
89269
|
+
* full). The count lags deletes by one to three minutes.
|
|
89270
|
+
*/
|
|
89271
|
+
async getServiceLimit() {
|
|
89272
|
+
return this.dxSaaSService.oiGet('oi/v2/sa/serviceLimitExceeded');
|
|
89273
|
+
}
|
|
89274
|
+
/**
|
|
89275
|
+
* Plans importing a store body (an export file) into this tenant, saving nothing:
|
|
89276
|
+
* reads the target's current state for every name in the file, takes each service's
|
|
89277
|
+
* metrics from the target ({@link ServiceImport.planImport}), and checks the service cap.
|
|
89278
|
+
*
|
|
89279
|
+
* @param opts.prefix - rename every service in the file first (cloning).
|
|
89280
|
+
*/
|
|
89281
|
+
async planImport(file, opts = {}) {
|
|
89282
|
+
const body = opts.prefix ? ServiceImport.renameBody(file, opts.prefix) : file;
|
|
89283
|
+
// Read only names the services list knows, so new ones aren't probed one 404 at a time.
|
|
89284
|
+
const listed = new Set((await this.getAllServices(100)).map((s) => s.name));
|
|
89285
|
+
const names = body.vertices.map((v) => v.attributes.name).filter((n) => listed.has(n));
|
|
89286
|
+
const target = await this.readServiceGraph(names, { allowMissing: true });
|
|
89287
|
+
const plan = ServiceImport.planImport(body, target);
|
|
89288
|
+
const cap = await this.getServiceLimit();
|
|
89289
|
+
const headroom = cap.limit - cap.totalServiceCnt;
|
|
89290
|
+
if (plan.created.length > headroom) {
|
|
89291
|
+
plan.blockers.push(`${plan.created.length} new services but only ${headroom} of ${cap.limit} left under the tenant's service cap`);
|
|
89292
|
+
}
|
|
89293
|
+
return { ...plan, headroom, limit: cap.limit };
|
|
89294
|
+
}
|
|
89295
|
+
/**
|
|
89296
|
+
* Commits a plan in ONE save. Re-reads the plan's services and refuses when a
|
|
89297
|
+
* value the plan replaces has moved; otherwise re-applies the changes onto the
|
|
89298
|
+
* fresh read (so concurrent edits elsewhere are kept) and saves. A plan whose
|
|
89299
|
+
* changes are already in place saves nothing (`response` is absent).
|
|
89300
|
+
*
|
|
89301
|
+
* @param opts.force - skip the conflict check and apply onto whatever is there now.
|
|
89302
|
+
* @throws ServiceBulk.ServiceConflictError listing what moved.
|
|
89303
|
+
* @remarks The server rejects an invalid payload whole — nothing is applied.
|
|
89304
|
+
*/
|
|
89305
|
+
async commitServicePlan(plan, opts = {}) {
|
|
89306
|
+
const checked = ServiceBulk.parsePlan(plan);
|
|
89307
|
+
const fresh = await this.readServiceGraph(checked.targets, {
|
|
89308
|
+
allowMissing: true,
|
|
89309
|
+
});
|
|
89310
|
+
if (!opts.force) {
|
|
89311
|
+
const conflicts = ServiceBulk.findConflicts(checked, fresh);
|
|
89312
|
+
if (conflicts.length)
|
|
89313
|
+
throw new ServiceBulk.ServiceConflictError(conflicts);
|
|
89314
|
+
}
|
|
89315
|
+
const rebased = ServiceBulk.planChanges(fresh, checked.targets, checked.changes);
|
|
89316
|
+
if (!rebased.plan.diff.length)
|
|
89317
|
+
return rebased;
|
|
89318
|
+
const response = await this.createService(rebased.body, { replace: true });
|
|
89319
|
+
return { ...rebased, response };
|
|
87978
89320
|
}
|
|
87979
89321
|
/** Builds a single-service store body (no edges) for `service export`. */
|
|
87980
89322
|
async exportServiceBody(serviceName) {
|
|
@@ -90284,5 +91626,5 @@ function createServiceMonolith(dxDoConfiguration, log = new NullSimpleLog()) {
|
|
|
90284
91626
|
};
|
|
90285
91627
|
}
|
|
90286
91628
|
|
|
90287
|
-
export { ALARM_CATEGORIES, ALARM_FILTER_CATEGORIES, ALARM_FILTER_DEFAULT_COLUMN_ORDER, ALARM_FILTER_DEFAULT_VISIBLE_COLUMNS, ALARM_FILTER_DISPLAY_COLUMN_KEYS, ALARM_FILTER_FIELD_PATHS, ALARM_QUEUE_CATEGORIES, ALARM_QUEUE_DEFAULT_COLUMN_ORDER, ALARM_QUEUE_DEFAULT_FILTER_SETTINGS, ALARM_QUEUE_DEFAULT_VISIBLE_COLUMNS, ALARM_QUEUE_DISPLAY_COLUMN_KEYS, ALARM_QUEUE_FILTER_CONDITIONS, ALARM_QUEUE_FILTER_SETTING_KEYS, ALARM_RECORD_PAGE_SIZE, ALARM_RECORD_WINDOW_CAP, ALARM_SEARCH_PAGE_CAP, ALARM_VIEW_CATEGORIES, ALARM_VIEW_FIELD_PATHS, ALARM_VIEW_SEARCH_PATHS, ALGORITHMIC_SITUATIONS_KEY, ANOMALY_DETECTION_PRODUCTS, AXAActivities, AccService, AgentService, AgentTrace, AlarmCategorySchema, AlarmEnrichment, AlarmEnrichmentFilter, AlarmFilterFieldSchema, AlarmFilterFieldsResponseSchema, AlarmFilterWriteBodySchema, AlarmFilterWriteResponseSchema, AlarmQueueDeleteResponseSchema, AlarmQueueDetailSchema, AlarmQueueFieldSchema, AlarmQueueFieldsResponseSchema, AlarmQueueFilterSettingsSchema, AlarmQueueListResponseSchema, AlarmQueuePreferencesResponseSchema, AlarmQueuePreferencesSchema, AlarmQueueSchema, AlarmQueueWriteBodySchema, AlarmQueueWriteResponseSchema, AlarmRecordSchema, AlarmRecordSearchResponseSchema, AlarmService, AlertDefinitionResponse, AlertResponse, AlertResponseV2, AlertService, AlignmentSchema, AllAlarmQueuesResponseSchema, AnomalyAlertConfigSchema, AnomalyDetectionGroupDeleteResponseSchema, AnomalyDetectionGroupSaveRequestSchema, AnomalyDetectionGroupSaveResponseSchema, AnomalyDetectionGroupSchema, AnomalyDetectionGroupSearchRequestSchema, AnomalyDetectionGroupSearchResponseSchema, AnomalyGroupMetricsEntrySchema, AnomalyGroupMetricsRequestSchema, AnomalyGroupMetricsResponseSchema, AnomalyMetricFieldsRequestSchema, AnomalyMetricFieldsResponseSchema, AnyChannelSchema, ApmUniverseService, AppVersionSchema, AppVersionsResponseSchema, AsmService, AttributeExpressionComparatorSchema, AttributeExpressionOperatorSchema, AttributeExpressionSchema, AttributeFilterOperator, AttributeNameAllSpecifierSchema, AttributeNameAndSpecifierSchema, AttributeNameAnyNumericSpecifierSchema, AttributeNameAttributeSpecifierSchema, AttributeNameChildrenSpecifierSchema, AttributeNameExactSpecifierSchema, AttributeNameFolderSpecifierSchema, AttributeNameNoneSpecifierSchema, AttributeNameNotSpecifierSchema, AttributeNameOperatorSpecifierSchema, AttributeNameOrSpecifierSchema, AttributeNameRegExSpecifierSchema, AttributeNameSpecifierSchema, AttributeNameTypeSpecifierSchema, AttributeService, AttributeValueAsFieldSchema, AuditGlobalQueryRequestSchema, AuditQueryRequestSchema, AuditQueryResponseSchema, AuditRecordEsSchema, AuditRecordSchema, AuditStoreResponseSchema, AuthorizationService, AxaService, BlobAllFilterSchema, BlobAsyncCommandSchema, BlobAsyncDeleteSchemaCommandSchema, BlobAsyncResultEntrySchema, BlobAsyncResultRequestSchema, BlobAsyncResultResponseSchema, BlobAsyncResultStateSchema, BlobAttributeExpressionSchema, BlobAttributeFilterSchema, BlobAttributesSchema, BlobBulkDeleteEntrySchema, BlobBulkDeleteRequestSchema, BlobBulkDeleteResponseSchema, BlobBulkItemSchema, BlobBulkStoreRequestSchema, BlobBulkStoreResponseSchema, BlobDeleteParamsSchema, BlobDeleteResponseSchema, BlobDeleteSchemaResultSchema, BlobExecuteAsyncRequestSchema, BlobExecuteAsyncResponseSchema, BlobFetchParamsSchema, BlobFileEnvelopeSchema, BlobFilterSchema, BlobMetadataSchema, BlobQueryRequestSchema, BlobQueryResponseSchema, BlobSchemaItemSchema, BlobSchemaListRequestSchema, BlobSchemaListResponseSchema, BlobService, BlobStoreParamsSchema, BlobStoreResponseSchema, CLUSTERING_POLICY_BUILTIN_AUTHORS, CLUSTERING_POLICY_CONDITIONS, CLUSTERING_POLICY_PRESENCE_CONDITIONS, CLUSTERING_POLICY_PREVIEW_RANGES, CLUSTERING_POLICY_STATUSES, CURL_COHORT_VAR, CURL_HOST_VAR, CURL_TOKEN_VAR, CUSTOM_FIELD_PATTERN, CalendarIntervalSchema, CancelRevokeRequestSchema, ChannelDeleteResponseSchema, ChannelEnvelopeSchema, ChannelLinkedEntitySchema, ChannelListResponseSchema, ChannelService, ChannelTemplateRefSchema, ChannelWriteBodySchema, ChannelWriteResponseSchema, ClusteringCriteriaValuesSchema, ClusteringCriterionPropertiesSchema, ClusteringCriterionSchema, ClusteringPolicyCriteriaSchema, ClusteringPolicyPreviewResponseSchema, ClusteringPolicySchema, ClusteringPolicySearchRequestSchema, ClusteringPolicySearchResponseSchema, ClusteringPolicyService, ClusteringPolicyWriteBodySchema, ClusteringPreviewClusterSchema, ClusteringPreviewTemplateSchema, CreateAgentTokenRequestSchema, CreateInternalTokenRequestSchema, CreateServices, CreateTenantTokenRequestSchema, CreateUserTokenRequestSchema, DEFAULT_EXPERIENCE_REQUEST_BODY, DEFAULT_EXTERNAL_ID_FORMAT, DEFAULT_WEBHOOK_AUTH_DETAILS, DEFAULT_WEBHOOK_PAYLOAD_FIELDS, DRAFT_FILE_SUFFIX, DXChannel, DXO2_SAAS_GATEWAYS, DXO2_SAAS_GATEWAY_HOSTNAMES, DXO2_STATUS_PAGE_URL, DashboardPermissionsUpdateRequest, DashboardSearch, DashboardService, DataStoreAuditService, DataStoreAuthViewsService, DataStoreBlobStorageService, DataStoreFeaturesService, DataStoreMetricsMetadataService, DataStoreNASSQLService, DataStoreNASSService, DataStoreStatesService, DataStoreTASService, DataStoreTokensService, DefaultViewsResponseSchema, DeleteTokenRequestSchema, DeleteTokensResponseSchema, DxO2SaasRegionSchema, DxSaasService, DxoiService, ENRICHMENT_FILTER_CONDITIONS, ENRICHMENT_PREVIEW_WINDOWS, ENRICHMENT_SOURCES, EXPORT_INCLUDE_TOKEN_ENV, EdgeNumericIdSchema, EmptyCriteriaSchema, EnrichmentCustomFieldSchema, EnrichmentCustomFieldsResponseSchema, EnrichmentMappingSchema, EnrichmentPreviewResponseSchema, EnrichmentRuleSchema, EnrichmentRuleWriteBodySchema, EnrichmentRulesResponseSchema, EnrichmentSchema, EventService, ExperienceService, FILTER_FIELDS, FeatureAttributesSchema, FeatureDatascopeSchema, FeatureDeleteRequestSchema, FeatureFieldSchema, FeatureFieldTypeSchema, FeatureFilterSchema, FeatureFilterTemplateSchema, FeatureFilterTemplateTypeSchema, FeatureIdFilterSchema, FeatureListResponseSchema, FeatureNodeSchema, FeatureQueryRequestSchema, FeatureStoreRequestSchema, FeatureStoreResponseSchema, FeatureToggleListResponseSchema, FeatureToggleListSchema, FillModeSchema, FilterOperation, FolderNameAllSpecifierSchema, FolderNameAndSpecifierSchema, FolderNameChildrenSpecifierSchema, FolderNameExactSpecifierSchema, FolderNameNoneSpecifierSchema, FolderNameNotSpecifierSchema, FolderNameOrSpecifierSchema, FolderNameRegExSpecifierSchema, FolderNameSpecifierSchema, GenericChannelSchema, GraphResponse, GraphService, INVENTORY_QUEUE_CATEGORY, INVENTORY_QUEUE_DEFAULT_SELECT_TOGGLES, INVENTORY_QUEUE_DEFAULT_VISIBLE_COLUMNS, INVENTORY_QUEUE_FILTER_CONDITIONS, INVENTORY_QUEUE_NO_GROUP, ITSM_DEFAULT_TICKET_TEMPLATE, ITSM_SECRET_KEYS, ImportTokenRequestSchema, IncompleteAlarmSearchError, InventorizeDeleteResponseSchema, InventorizeDraftSchema, InventorizeLayerSchema, InventorizePreviewResponseSchema, InventorizePreviewSchema, InventorizeRuleListResponseSchema, InventorizeRuleSchema, InventorizeSaveResponseSchema, Inventory, InventoryAttributes, InventoryGroupSchema, InventoryGroupsResponseSchema, InventoryQueueDeleteResponseSchema, InventoryQueueDetailSchema, InventoryQueueFieldSchema, InventoryQueueFieldsResponseSchema, InventoryQueueFilterAtomSchema, InventoryQueueListResponseSchema, InventoryQueuePreferencesResponseSchema, InventoryQueuePreferencesSchema, InventoryQueueSchema, InventoryQueueWriteBodySchema, InventoryQueueWriteResponseSchema, InventoryService, ItsmChannelSchema, ItsmPropertySchema, ItsmTestConnectionRequestSchema, ItsmTestConnectionResponseSchema, JEXL_CONTEXT_CATALOG, JEXL_SAMPLE_CONTEXT, JavaRegexError, JexlEvalError, JexlSyntaxError, JoinTypeSchema, JsExtensionService, LIFECYCLE_PAGE_SIZE, LOG_ANALYTICS_PRODUCT, LogCustomIngest, LogIngest, LogQuery, LogTypes, LogsService, MAX_SLIS_PER_GROUP, MESSAGE_TEMPLATE_ALARM_TYPES, METRIC_TYPE_ENUM, METRIC_TYPE_ENUM_NAMES, METRIC_TYPE_REGION, MServe, MaintenanceBulkDeleteResponseSchema, MaintenanceCreateRequestSchema, MaintenanceCreateResponseSchema, MaintenanceDeleteRequestSchema, MaintenanceDetailSchema, MaintenanceExcludedMemberSchema, MaintenanceFilterLeafSchema, MaintenanceFilterSchema, MaintenanceMemberSchema, MaintenanceMemberSourceSchema, MaintenanceMemberTypeSchema, MaintenancePreviewRequestSchema, MaintenancePreviewResponseSchema, MaintenanceScheduleSchema, MaintenanceSearchRequestSchema, MaintenanceSearchResponseSchema, MaintenanceService, MaintenanceSummarySchema, ManagementModuleIdSchema, ManagementModuleService, MatchType, MessageTemplateFieldSchema, MessageTemplateFieldsResponseSchema, MetadataMetricQueryResponseV2Schema, MetadataMetricQuerySchema, MetricAnomalyService, MetricAttributeSchema, MetricBatchService, MetricConfigCustomFilterSchema, MetricConfigFilterOrBlockSchema, MetricConfigFilterSchema, MetricFolderSchema, MetricGroupingService, MetricRegisterInputSchema, MetricRegisterRequestSchema, MetricRegisterResponseSchema, MetricRegisterSchema, MetricRegisterSourceSchema, MetricTypeEnumNameSchema, NASS, NASSService, NassDatapointSchema, NassExtensionDatapointSchema, NassRegularDatapointSchema, NassStoreRequestSchema, NassStoreResponseSchema, NassValueTypeSchema, NotificationService, NumericOperatorSchema, O2NotificationService, O2UniverseService, OIAlarm, OIService, OIUsersV2, OperatorSchema, POLICY_ALARM_CATEGORIES, POLICY_FILTER_CONDITIONS, POSTMAN_TOKEN_VAR, PRODUCT_STATUS_PROVISIONED, PerspectiveService, PlatformAlertService, PlatformFilters, PlatformManagementModuleService, PlatformMetricGroupingService, PolicyDeleteResponseSchema, PolicyFieldSchema, PolicyFieldsResponseSchema, PolicyFilterAtomSchema, PolicyFilterExpressionSchema, PolicyLinkedEntitySchema, PolicyNamingOperationSchema, PolicyWriteBodySchema, PolicyWriteResponseSchema, PublicKeyJsonResponseSchema, QuantileMethodSchema, QueryAllSpecifierSchema, QueryAndSpecifierSchema, QueryAttributeExpressionSchema, QueryAttributeSpecifierSchema, QueryColumnTypeSpecSchema, QueryFilterPredicateSpecSchema, QueryFunctionSpecSchema, QueryHintForceRangeSchema, QueryHintSchema, QueryIdSpecifierSchema, QueryMetricGroupSpecifierSchema, QueryMetricIdSchema, QueryNoneSpecifierSchema, QueryNotSpecifierSchema, QueryOrSpecifierSchema, QueryRangeSpecSchema, QueryRequestSchema, QueryResultCellSchema, QueryResultSchema, QueryResultTableSchema, QuerySpecSpecifierSchema, QuerySpecifierSchema, REDACTED_SECRET, RecurrencePattern, RevokeTokenRequestSchema, RevokeTokensResponseSchema, SLIService, SLI_DERIVED_METRIC_SOURCE, SMTP_DEFAULT_TEMPLATES, SOURCENAME_DIALECT_CATALOG, SQLService, ServiceDeskFieldSchema, ServiceDeskFieldsResponseSchema, ServiceExport, ServiceFilterSpecifierSchema, ServiceService, ServiceTransform, ServiceUniverseAccessEntrySchema, ServiceUniverseAccessSchema, ServiceUniverseAttributesSchema, ServiceUniverseBodySchema, ServiceUniverseListItemSchema, ServiceUniverseListResponseSchema, ServiceUniverseNassViewSchema, ServiceUniversePermissionSchema, ServiceUniverseQueryResponseSchema, ServiceUniverseSchema, ServiceUniverseService, ServiceUniverseTasSpecSchema, ServiceUniverseTasViewSchema, ServiceUniverseViewSchema, SessionService, SessionValidateRequestSchema, SessionValidateResponseSchema, SetDefaultViewRequestSchema, SimpleHTTPError, SituationLifecycle, SituationService, Situations, SliAggregationIntervalSchema, SliAlertEntrySchema, SliAlertOperatorSchema, SliAlertTargetSchema, SliDerivedMetricAttributeSchema, SliDerivedMetricsSchema, SliExpressionSchema, SliFilterSchema, SliFunctionCustomParamsSchema, SliFunctionInputSchema, SliFunctionOpSchema, SliFunctionOutputSchema, SliFunctionSchema, SliGroupDeleteResponseSchema, SliGroupMetricsEntrySchema, SliGroupMetricsRequestSchema, SliGroupMetricsResponseSchema, SliGroupSaveRequestSchema, SliGroupSaveResponseSchema, SliGroupSchema, SliGroupSearchRequestSchema, SliGroupSearchResponseSchema, SliMetricFieldSchema, SliMetricFieldsRequestSchema, SliMetricFieldsResponseSchema, SliThresholdComparatorSchema, SliThresholdSchema, SloCalendarPeriodSchema, SloFunctionOpSchema, SloFunctionSchema, SmtpChannelConfigsSchema, SmtpChannelSchema, SmtpTestInputSchema, SmtpTestRequestSchema, SmtpTestResponseSchema, SourceNameAllSpecifierSchema, SourceNameAndSpecifierSchema, SourceNameExactSpecifierSchema, SourceNameNoneSpecifierSchema, SourceNameNotSpecifierSchema, SourceNameOrSpecifierSchema, SourceNamePartOperatorSpecifierSchema, SourceNameRegExSpecifierSchema, SourceNameSpecifierSchema, StatusPageComponentSchema, StatusPageComponentsSchema, StoredCriteriaSchema, TAGS_ATTRIBUTE_KEY, TAS, TASGraph, TASService, TC_METRIC_CAP, TC_RESERVED_CUSTOM_ATTRIBUTE_KEYS, TC_STANDARD_ATTRIBUTE_KEYS, TICKET_ENRICHMENT_ALARM_TYPES, TICKET_ENRICHMENT_FIELD_CODES, TasAddFlowsFilterSchema, TasAddTransitioningEdgesFilterSchema, TasAddWireContextFilterSchema, TasAddWiresFilterSchema, TasAllFilterSchema, TasAnalyticBaseSchema, TasAnalyticResultSchema, TasAndFilterSchema, TasAttributeAlertStatisticsSchema, TasAttributeFilterModeSchema, TasAttributeFilterSchema, TasAttributeNameSchema, TasAttributeTypeSchema, TasCollectAttributeNamesFilterSchema, TasCollectAttributeNamesResultSchema, TasCollectAttributeResultSchema, TasCollectAttributesFilterSchema, TasCollectCardInfoFilterSchema, TasCollectCardInfoResultSchema, TasCollectCardInfoTierSchema, TasCollectCountsFilterSchema, TasCollectCountsResultSchema, TasCollectExperienceAttributesFilterSchema, TasCollectExperienceSelectorSchema, TasCollectGroupingInfoFilterSchema, TasCollectGroupingInfoResultSchema, TasCollectVertexIdFilterSchema, TasCoverageFilterSchema, TasEdgeSchema, TasEmptyFilterSchema, TasExternalIdSchema, TasFilterSchema, TasFollowPathFilterSchema, TasFollowPathFlowFilterSchema, TasFollowPathTypeSchema, TasGraphSchema, TasGroupingAlertStatisticsSchema, TasGroupingInfoSchema, TasGroupingItemSchema, TasJoinFilterSchema, TasJoinTypeSchema, TasLayerFilterSchema, TasLegacyFilterSchema, TasLuceneFilterSchema, TasNotFilterSchema, TasOrFilterSchema, TasOrderSchema, TasProjectionFilterSchema, TasQuerySchema, TasServiceFilterSchema, TasStatusFilterSchema, TasStoreAttributeValueSchema, TasStoreChangeSchema, TasStoreEdgeSchema, TasStoreGraphInputSchema, TasStoreGraphResponseSchema, TasStoreGraphSchema, TasStoreVertexSchema, TasTakeEdgesFilterSchema, TasTakeFlowsFilterSchema, TasTakeVerticesFilterSchema, TasTraverseFilterSchema, TasVariableFilterSchema, TasVariableSchema, TasVertexIdFilterSchema, TasVertexSchema, TasViewSchema, TemplateDeleteResponseSchema, TemplateWriteBodySchema, TemplateWriteResponseSchema, TenantConfigAttributeSchema, TenantConfigAttributesResponseSchema, TenantConfigAttributesWriteBodySchema, TenantConfigAttributesWriteResponseSchema, TenantProductSchema, TenantProductsResponseSchema, TenantRoleSchema, TenantRolesResponseSchema, TenantService, TicketEnrichmentAlarmFieldSchema, TicketEnrichmentAlarmFieldsResponseSchema, TicketEnrichmentListResponseSchema, TicketEnrichmentMappingSchema, TicketEnrichmentRuleSchema, TicketEnrichmentWriteBodySchema, TicketEnrichmentWriteResponseSchema, TokenCreateResponseSchema, TokenDetailsSchema, TokenGetAndVerifyRequestSchema, TokenMetadataSchema, TokenQueryRequestSchema, TokenQueryResponseSchema, TokenVerifyRequestSchema, Trace, TraversalEdgeFilterSchema, TraversalVertexFilterSchema, TraverseCollectSchema, TraverseDirectionSchema, TraverseSchema, UIM_LOGS_INGESTION_PATH, UpdateAgentTokenRequestSchema, UpdateTenantTokenRequestSchema, UpdateUserTokenRequestSchema, VertexGroupSchema, VertexMappingConfigurationModule, VertexService, VertexStateAlertFilterSchema, VertexStateAllFilterSchema, VertexStateAnalyticResultSchema, VertexStateAndFilterSchema, VertexStateClampSettingSchema, VertexStateCollectVertexGroupStatusFilterSchema, VertexStateEmptyFilterSchema, VertexStateExternalIdInputSchema, VertexStateExternalIdResponseSchema, VertexStateExternalIdSchema, VertexStateFetchRequestSchema, VertexStateFetchResponseSchema, VertexStateFilterSchema, VertexStateGroupResultSchema, VertexStateInputSchema, VertexStateManagementModuleFilterSchema, VertexStateMetricFilterSchema, VertexStateNamespaceFilterSchema, VertexStateNumericIdSchema, VertexStateOrFilterSchema, VertexStateProjectionSchema, VertexStateRangeRequestSchema, VertexStateRangeResponseSchema, VertexStateRepublishRequestSchema, VertexStateResponseItemSchema, VertexStateSchema, VertexStateStateFilterSchema, VertexStateStoreRequestSchema, VertexStateStoreResponseSchema, VertexStateVertexIdFilterSchema, VertexStatusChanges, ViewAccessEntrySchema, ViewAccessRoleSchema, ViewAccessSchema, ViewActiveFilterSchema, ViewAllFilterSchema, ViewAndFilterSchema, ViewAttributeExpressionSchema, ViewAttributeFilterSchema, ViewAttributesSchema, ViewBodySchema, ViewFilterSchema, ViewIdFilterSchema, ViewListResponseSchema, ViewNassSpecSchema, ViewOrFilterSchema, ViewOwnerSchema, ViewQueryRequestSchema, ViewQueryResponseSchema, ViewResponseSchema, ViewSearchRequestSchema, ViewSpecsSchema, ViewTasSpecSchema, WebhookAuthDetailsSchema, WebhookChannelSchema, WebhookSpecSchema, WebhookTestInputSchema, WebhookTestRequestSchema, WebhookTestResponseSchema, ags, agsresponse, alarmFilterDisplayColumnsFor, alarmRecordTime, alertsForSliIndex, algorithmicSituationsEnabled, allAlarmQueues, apiTokenCreate, apiTokenDelete, apiTokenGet, apiTokenList, apiTokenUpdate, appendSli, appendSloTriplet, attributeFilterTargets, authHeaderValue, buildAlarmFilterUpdateBody, buildAlarmQueueFilterExpression, buildAlarmQueueUpdateBody, buildAlertEntry, buildClusteringPolicyUpdateBody, buildCustomLogPayload, buildEnrichmentRuleUpdateBody, buildInventoryCustomFilter, buildInventoryQueueUpdateBody, buildPolicyFilterExpression, buildSliFunction, buildSloTriplet, buildTemplateRefs, buildUimLogPayload, capVertexDetail, checkGet, chunkPayloads, classifyIngestionError, compileTcSourceName, composeMetricTypeBits, contactActivate, contactDelete, contactTestSend, contactsBlockDelete, contactsBlockPut, contactsConfirm, contactsCreate, contactsGet, contactsGetDetail, contactsReplaceNotificationsWith, contactsRequestConfirmationCode, contactsUpdate, convertLegacyConfiguration, createCurlCommand, createCurlScript, createPostmanRequest, createServiceMonolith, customAttributeKeyIssues, decodeMetricTypeBits, defaultItsmPropertyList, defaultRuleName, deriveSliAs, deriveVertexName, describeClusteringCriteria, displayColumnsFor, dottedFileSlot, draftKey, encodeItsmSecret, ensureParallelAlerts, escapeRegExp, evaluate, evaluateTemplate, example, excludedAttributes, exportAlarmRecords, exportFileLabel, exportIncludesToken, expressionPipelineNames, extractComponentGridData, findAlertByTarget, findInventoryGroup, findProduct, findRedactedSecretPaths, findSliByName, flattenAxiosHeaders, folderAccessGet, folderDelete, folderGet, folderPost, folderUpdate, foldersList, formExternalId, getDataStoreSchema, getUserTokenSub, getUserTokenTid, getVertexAttributeValue, getVertexAttributeValueOrNull, hasTypeTagsFlag, hasVertexAttribute, impliedDxo2Version, incrementVariant, inventoryDisplayColumnsFor, inventoryQueuesOf, inventorySearchRequestBodyExample, inventorySearchResponseBody, isAlarmFilter, isAlarmQueue, isAlarmQueueNotFound, isAuthorizationHeader, isBuiltInClusteringPolicy, isBuiltInPolicy, isBuiltInTemplate, isDataStoreSchemaType, isEmptyCriteria, isInventoryQueueNotFound, isPersonalQueue, isProductProvisioned, isTemplate, isTenantToken, isUserToken, isWildcardOnlySourceName, itsmMapToProperties, itsmPropertiesToMap, javaFullMatch, javaRegexToJs, javaReplaceAll, javaReplaceFirst, javaSplit, lintSourceName, listDataStoreSchemaOps, listSlis, locationsCreate, locationsDelete, locationsGet, locationsGetAll, locationsGetByType, locationsLeafGetFilter, locationsPost, logGet, logGetEvent, logIngestionURLForGateway, maintenanceDelete, maintenanceDeleteWindows, maintenanceFilter, maintenanceGet, maintenanceGetDetail, maintenanceGetWindows, maintenanceGetWindowsDetail, maintenanceUpdateWindowsDetail, maintenancesCreate, maintenancesImmediateDelete, maintenancesImmediatePut, maintenancesPostWindows, maintenancesUpdate, measureBytes, messageGet, messageTemplateVariables, messagesList, monitorActivate, monitorCreate, monitorDeactivate, monitorDelete, monitorGet, monitorGetAll, monitorUpdate, normalizeAlarmQueueSharing, oauthClientTokensCreate, oauthClientTokensDelete, oauthClientTokensGet, oauthClientTokensList, oauthClientTokensUpdate, oauthCreateToken, oauthGetRefreshTokenList, oauthGetTokenList, oauthRefreshTokenDeleteId, oauthTokenCognateDelete, oauthTokenCognateDeleteCurrent, oauthTokenDelete, oauthTokenDeleteCurrent, orBlocksByField, parseAlarmRecordTime, parseExpression, parseExternalIdFormat, parseFilter, parseSaasGateway, parseServiceNowUrl, pipeGroupRanges, planEnrichmentReorder, policyCategoryGuard, policyFieldBounds, policyFilterAtoms, producedMetricName, projectCustomAttributes, projectRule, pruneOrphanSloFunctions, readLifecyclePages, redactChannelSecrets, reencodeItsmForWrite, removeAlert, removeSli, removeSloTriplet, resolveAnomalyDetectionProduct, resolveEnrichmentMappings, resolveWebhookPayload, sampleServiceDetailRequestBody, searchAlarmWindows, searchUniverse, sendWithRetry, serviceDetailResponseBody, settingsGet, settingsGetDetail, settingsUpdate, sharedRoleDelta, sleep, sliHumanName, sloTripletFor, sortRulesByPriority, sourceNameBattery, sourceNameMatrix, splitAttributePath, splitTemplate, standardVertexAttributes, stationDelete, stationsAgentType, stationsCreate, stationsDeleteMaintenance, stationsGet, stationsGetAgents, stationsLatest, stationsList, stationsOnpremiseConnected, stationsOnpremiseConnectedAll, stationsOnpremiseList, stationsPutMaintenance, stationsUpdate, statistic, summarizeDataStoreSchema, tagsGetAll, tcSourceNameMatches, tcSourceNameToJavaRegex, tcSourceNameToMmPattern, templateUsage, tenantConfigAttribute, timezonesList, toAlarmFilterWriteBody, toAlarmQueueWriteBody, toAnomalyDetectionGroupSaveRequest, toAnomalyGroupMetricsRequest, toChannelWriteBody, toClusteringPolicyPreviewBody, toClusteringPolicyWriteBody, toEnrichmentRuleCreateBody, toGroupMetricsRequest, toInventoryQueueWriteBody, toItsmTestConnectionRequest, toPolicyWriteBody, toSliGroupSaveRequest, toTemplateWriteBody, toTicketEnrichmentWriteBody, tokenize, translateRuleToMmQuery, truthy, userBlockDelete, userBlockPut, userDelete, userGet, userLockDelete, userPut, userSubaccountsGet, userSubaccountsPost, verifyAndDumpLegacyConfiguration, verifyAndDumpVersion3Configuration, verifyAndDumpVersion4Configuration, vertexMatchesFilters, visibleAlarmQueueColumns, visibleInventoryColumns };
|
|
91629
|
+
export { ALARM_CATEGORIES, ALARM_FILTER_CATEGORIES, ALARM_FILTER_DEFAULT_COLUMN_ORDER, ALARM_FILTER_DEFAULT_VISIBLE_COLUMNS, ALARM_FILTER_DISPLAY_COLUMN_KEYS, ALARM_FILTER_FIELD_PATHS, ALARM_QUEUE_CATEGORIES, ALARM_QUEUE_DEFAULT_COLUMN_ORDER, ALARM_QUEUE_DEFAULT_FILTER_SETTINGS, ALARM_QUEUE_DEFAULT_VISIBLE_COLUMNS, ALARM_QUEUE_DISPLAY_COLUMN_KEYS, ALARM_QUEUE_FILTER_CONDITIONS, ALARM_QUEUE_FILTER_SETTING_KEYS, ALARM_RECORD_PAGE_SIZE, ALARM_RECORD_WINDOW_CAP, ALARM_SEARCH_PAGE_CAP, ALARM_VIEW_CATEGORIES, ALARM_VIEW_FIELD_PATHS, ALARM_VIEW_SEARCH_PATHS, ALGORITHMIC_SITUATIONS_KEY, ANOMALY_DETECTION_PRODUCTS, AXAActivities, AccService, AgentService, AgentTrace, AlarmCategorySchema, AlarmEnrichment, AlarmEnrichmentFilter, AlarmFilterFieldSchema, AlarmFilterFieldsResponseSchema, AlarmFilterWriteBodySchema, AlarmFilterWriteResponseSchema, AlarmQueueDeleteResponseSchema, AlarmQueueDetailSchema, AlarmQueueFieldSchema, AlarmQueueFieldsResponseSchema, AlarmQueueFilterSettingsSchema, AlarmQueueListResponseSchema, AlarmQueuePreferencesResponseSchema, AlarmQueuePreferencesSchema, AlarmQueueSchema, AlarmQueueWriteBodySchema, AlarmQueueWriteResponseSchema, AlarmRecordSchema, AlarmRecordSearchResponseSchema, AlarmService, AlertDefinitionResponse, AlertResponse, AlertResponseV2, AlertService, AlignmentSchema, AllAlarmQueuesResponseSchema, AnomalyAlertConfigSchema, AnomalyDetectionGroupDeleteResponseSchema, AnomalyDetectionGroupSaveRequestSchema, AnomalyDetectionGroupSaveResponseSchema, AnomalyDetectionGroupSchema, AnomalyDetectionGroupSearchRequestSchema, AnomalyDetectionGroupSearchResponseSchema, AnomalyGroupMetricsEntrySchema, AnomalyGroupMetricsRequestSchema, AnomalyGroupMetricsResponseSchema, AnomalyMetricFieldsRequestSchema, AnomalyMetricFieldsResponseSchema, AnyChannelSchema, ApmUniverseService, AppVersionSchema, AppVersionsResponseSchema, AsmService, AttributeExpressionComparatorSchema, AttributeExpressionOperatorSchema, AttributeExpressionSchema, AttributeFilterOperator, AttributeNameAllSpecifierSchema, AttributeNameAndSpecifierSchema, AttributeNameAnyNumericSpecifierSchema, AttributeNameAttributeSpecifierSchema, AttributeNameChildrenSpecifierSchema, AttributeNameExactSpecifierSchema, AttributeNameFolderSpecifierSchema, AttributeNameNoneSpecifierSchema, AttributeNameNotSpecifierSchema, AttributeNameOperatorSpecifierSchema, AttributeNameOrSpecifierSchema, AttributeNameRegExSpecifierSchema, AttributeNameSpecifierSchema, AttributeNameTypeSpecifierSchema, AttributeService, AttributeValueAsFieldSchema, AuditGlobalQueryRequestSchema, AuditQueryRequestSchema, AuditQueryResponseSchema, AuditRecordEsSchema, AuditRecordSchema, AuditStoreResponseSchema, AuthorizationService, AxaService, BlobAllFilterSchema, BlobAsyncCommandSchema, BlobAsyncDeleteSchemaCommandSchema, BlobAsyncResultEntrySchema, BlobAsyncResultRequestSchema, BlobAsyncResultResponseSchema, BlobAsyncResultStateSchema, BlobAttributeExpressionSchema, BlobAttributeFilterSchema, BlobAttributesSchema, BlobBulkDeleteEntrySchema, BlobBulkDeleteRequestSchema, BlobBulkDeleteResponseSchema, BlobBulkItemSchema, BlobBulkStoreRequestSchema, BlobBulkStoreResponseSchema, BlobDeleteParamsSchema, BlobDeleteResponseSchema, BlobDeleteSchemaResultSchema, BlobExecuteAsyncRequestSchema, BlobExecuteAsyncResponseSchema, BlobFetchParamsSchema, BlobFileEnvelopeSchema, BlobFilterSchema, BlobMetadataSchema, BlobQueryRequestSchema, BlobQueryResponseSchema, BlobSchemaItemSchema, BlobSchemaListRequestSchema, BlobSchemaListResponseSchema, BlobService, BlobStoreParamsSchema, BlobStoreResponseSchema, CLUSTERING_POLICY_BUILTIN_AUTHORS, CLUSTERING_POLICY_CONDITIONS, CLUSTERING_POLICY_PRESENCE_CONDITIONS, CLUSTERING_POLICY_PREVIEW_RANGES, CLUSTERING_POLICY_STATUSES, CURL_COHORT_VAR, CURL_HOST_VAR, CURL_TOKEN_VAR, CUSTOM_FIELD_PATTERN, CalendarIntervalSchema, CancelRevokeRequestSchema, ChannelDeleteResponseSchema, ChannelEnvelopeSchema, ChannelLinkedEntitySchema, ChannelListResponseSchema, ChannelService, ChannelTemplateRefSchema, ChannelWriteBodySchema, ChannelWriteResponseSchema, ClusteringCriteriaValuesSchema, ClusteringCriterionPropertiesSchema, ClusteringCriterionSchema, ClusteringPolicyCriteriaSchema, ClusteringPolicyPreviewResponseSchema, ClusteringPolicySchema, ClusteringPolicySearchRequestSchema, ClusteringPolicySearchResponseSchema, ClusteringPolicyService, ClusteringPolicyWriteBodySchema, ClusteringPreviewClusterSchema, ClusteringPreviewTemplateSchema, CreateAgentTokenRequestSchema, CreateInternalTokenRequestSchema, CreateServices, CreateTenantTokenRequestSchema, CreateUserTokenRequestSchema, DEFAULT_EXPERIENCE_REQUEST_BODY, DEFAULT_EXTERNAL_ID_FORMAT, DEFAULT_WEBHOOK_AUTH_DETAILS, DEFAULT_WEBHOOK_PAYLOAD_FIELDS, DRAFT_FILE_SUFFIX, DXChannel, DXO2_SAAS_GATEWAYS, DXO2_SAAS_GATEWAY_HOSTNAMES, DXO2_STATUS_PAGE_URL, DashboardPermissionsUpdateRequest, DashboardSearch, DashboardService, DataStoreAuditService, DataStoreAuthViewsService, DataStoreBlobStorageService, DataStoreFeaturesService, DataStoreMetricsMetadataService, DataStoreNASSQLService, DataStoreNASSService, DataStoreStatesService, DataStoreTASService, DataStoreTokensService, DefaultViewsResponseSchema, DeleteTokenRequestSchema, DeleteTokensResponseSchema, DxO2SaasRegionSchema, DxSaasService, DxoiService, ENRICHMENT_FILTER_CONDITIONS, ENRICHMENT_PREVIEW_WINDOWS, ENRICHMENT_SOURCES, EXPORT_INCLUDE_TOKEN_ENV, EdgeNumericIdSchema, EmptyCriteriaSchema, EnrichmentCustomFieldSchema, EnrichmentCustomFieldsResponseSchema, EnrichmentMappingSchema, EnrichmentPreviewResponseSchema, EnrichmentRuleSchema, EnrichmentRuleWriteBodySchema, EnrichmentRulesResponseSchema, EnrichmentSchema, EventService, ExperienceService, FILTER_FIELDS, FeatureAttributesSchema, FeatureDatascopeSchema, FeatureDeleteRequestSchema, FeatureFieldSchema, FeatureFieldTypeSchema, FeatureFilterSchema, FeatureFilterTemplateSchema, FeatureFilterTemplateTypeSchema, FeatureIdFilterSchema, FeatureListResponseSchema, FeatureNodeSchema, FeatureQueryRequestSchema, FeatureStoreRequestSchema, FeatureStoreResponseSchema, FeatureToggleListResponseSchema, FeatureToggleListSchema, FillModeSchema, FilterOperation, FolderNameAllSpecifierSchema, FolderNameAndSpecifierSchema, FolderNameChildrenSpecifierSchema, FolderNameExactSpecifierSchema, FolderNameNoneSpecifierSchema, FolderNameNotSpecifierSchema, FolderNameOrSpecifierSchema, FolderNameRegExSpecifierSchema, FolderNameSpecifierSchema, GenericChannelSchema, GraphResponse, GraphService, INVENTORY_QUEUE_CATEGORY, INVENTORY_QUEUE_DEFAULT_SELECT_TOGGLES, INVENTORY_QUEUE_DEFAULT_VISIBLE_COLUMNS, INVENTORY_QUEUE_FILTER_CONDITIONS, INVENTORY_QUEUE_NO_GROUP, ITSM_DEFAULT_TICKET_TEMPLATE, ITSM_SECRET_KEYS, ImportTokenRequestSchema, IncompleteAlarmSearchError, InventorizeDeleteResponseSchema, InventorizeDraftSchema, InventorizeLayerSchema, InventorizePreviewResponseSchema, InventorizePreviewSchema, InventorizeRuleListResponseSchema, InventorizeRuleSchema, InventorizeSaveResponseSchema, Inventory, InventoryAttributes, InventoryGroupSchema, InventoryGroupsResponseSchema, InventoryQueueDeleteResponseSchema, InventoryQueueDetailSchema, InventoryQueueFieldSchema, InventoryQueueFieldsResponseSchema, InventoryQueueFilterAtomSchema, InventoryQueueListResponseSchema, InventoryQueuePreferencesResponseSchema, InventoryQueuePreferencesSchema, InventoryQueueSchema, InventoryQueueWriteBodySchema, InventoryQueueWriteResponseSchema, InventoryService, ItsmChannelSchema, ItsmPropertySchema, ItsmTestConnectionRequestSchema, ItsmTestConnectionResponseSchema, JEXL_CONTEXT_CATALOG, JEXL_SAMPLE_CONTEXT, JavaRegexError, JexlEvalError, JexlSyntaxError, JoinTypeSchema, JsExtensionService, LIFECYCLE_PAGE_SIZE, LOG_ANALYTICS_PRODUCT, LogCustomIngest, LogIngest, LogQuery, LogTypes, LogsService, MAX_SLIS_PER_GROUP, MESSAGE_TEMPLATE_ALARM_TYPES, METRIC_TYPE_ENUM, METRIC_TYPE_ENUM_NAMES, METRIC_TYPE_REGION, MServe, MaintenanceBulkDeleteResponseSchema, MaintenanceCreateRequestSchema, MaintenanceCreateResponseSchema, MaintenanceDeleteRequestSchema, MaintenanceDetailSchema, MaintenanceExcludedMemberSchema, MaintenanceFilterLeafSchema, MaintenanceFilterSchema, MaintenanceMemberSchema, MaintenanceMemberSourceSchema, MaintenanceMemberTypeSchema, MaintenancePreviewRequestSchema, MaintenancePreviewResponseSchema, MaintenanceScheduleSchema, MaintenanceSearchRequestSchema, MaintenanceSearchResponseSchema, MaintenanceService, MaintenanceSummarySchema, ManagementModuleIdSchema, ManagementModuleService, MatchType, MessageTemplateFieldSchema, MessageTemplateFieldsResponseSchema, MetadataMetricQueryResponseV2Schema, MetadataMetricQuerySchema, MetricAnomalyService, MetricAttributeSchema, MetricBatchService, MetricConfigCustomFilterSchema, MetricConfigFilterOrBlockSchema, MetricConfigFilterSchema, MetricFolderSchema, MetricGroupingService, MetricRegisterInputSchema, MetricRegisterRequestSchema, MetricRegisterResponseSchema, MetricRegisterSchema, MetricRegisterSourceSchema, MetricTypeEnumNameSchema, NASS, NASSService, NassDatapointSchema, NassExtensionDatapointSchema, NassRegularDatapointSchema, NassStoreRequestSchema, NassStoreResponseSchema, NassValueTypeSchema, NotificationService, NumericOperatorSchema, O2NotificationService, O2UniverseService, OIAlarm, OIService, OIUsersV2, OperatorSchema, POLICY_ALARM_CATEGORIES, POLICY_FILTER_CONDITIONS, POSTMAN_TOKEN_VAR, PRODUCT_STATUS_PROVISIONED, PerspectiveService, PlatformAlertService, PlatformFilters, PlatformManagementModuleService, PlatformMetricGroupingService, PolicyDeleteResponseSchema, PolicyFieldSchema, PolicyFieldsResponseSchema, PolicyFilterAtomSchema, PolicyFilterExpressionSchema, PolicyLinkedEntitySchema, PolicyNamingOperationSchema, PolicyWriteBodySchema, PolicyWriteResponseSchema, PublicKeyJsonResponseSchema, QuantileMethodSchema, QueryAllSpecifierSchema, QueryAndSpecifierSchema, QueryAttributeExpressionSchema, QueryAttributeSpecifierSchema, QueryColumnTypeSpecSchema, QueryFilterPredicateSpecSchema, QueryFunctionSpecSchema, QueryHintForceRangeSchema, QueryHintSchema, QueryIdSpecifierSchema, QueryMetricGroupSpecifierSchema, QueryMetricIdSchema, QueryNoneSpecifierSchema, QueryNotSpecifierSchema, QueryOrSpecifierSchema, QueryRangeSpecSchema, QueryRequestSchema, QueryResultCellSchema, QueryResultSchema, QueryResultTableSchema, QuerySpecSpecifierSchema, QuerySpecifierSchema, REDACTED_SECRET, RecurrencePattern, RevokeTokenRequestSchema, RevokeTokensResponseSchema, SERVICE_METRIC_PRESENCE_WINDOW_MS, SLIService, SLI_DERIVED_METRIC_SOURCE, SMTP_DEFAULT_TEMPLATES, SOURCENAME_DIALECT_CATALOG, SQLService, ServiceBulk, ServiceBulkSelect, ServiceDeskFieldSchema, ServiceDeskFieldsResponseSchema, ServiceExport, ServiceFilterSpecifierSchema, ServiceImport, ServiceService, ServiceTransform, ServiceUniverseAccessEntrySchema, ServiceUniverseAccessSchema, ServiceUniverseAttributesSchema, ServiceUniverseBodySchema, ServiceUniverseListItemSchema, ServiceUniverseListResponseSchema, ServiceUniverseNassViewSchema, ServiceUniversePermissionSchema, ServiceUniverseQueryResponseSchema, ServiceUniverseSchema, ServiceUniverseService, ServiceUniverseTasSpecSchema, ServiceUniverseTasViewSchema, ServiceUniverseViewSchema, SessionService, SessionValidateRequestSchema, SessionValidateResponseSchema, SetDefaultViewRequestSchema, SimpleHTTPError, SituationLifecycle, SituationService, Situations, SliAggregationIntervalSchema, SliAlertEntrySchema, SliAlertOperatorSchema, SliAlertTargetSchema, SliDerivedMetricAttributeSchema, SliDerivedMetricsSchema, SliExpressionSchema, SliFilterSchema, SliFunctionCustomParamsSchema, SliFunctionInputSchema, SliFunctionOpSchema, SliFunctionOutputSchema, SliFunctionSchema, SliGroupDeleteResponseSchema, SliGroupMetricsEntrySchema, SliGroupMetricsRequestSchema, SliGroupMetricsResponseSchema, SliGroupSaveRequestSchema, SliGroupSaveResponseSchema, SliGroupSchema, SliGroupSearchRequestSchema, SliGroupSearchResponseSchema, SliMetricFieldSchema, SliMetricFieldsRequestSchema, SliMetricFieldsResponseSchema, SliThresholdComparatorSchema, SliThresholdSchema, SloCalendarPeriodSchema, SloFunctionOpSchema, SloFunctionSchema, SmtpChannelConfigsSchema, SmtpChannelSchema, SmtpTestInputSchema, SmtpTestRequestSchema, SmtpTestResponseSchema, SourceNameAllSpecifierSchema, SourceNameAndSpecifierSchema, SourceNameExactSpecifierSchema, SourceNameNoneSpecifierSchema, SourceNameNotSpecifierSchema, SourceNameOrSpecifierSchema, SourceNamePartOperatorSpecifierSchema, SourceNameRegExSpecifierSchema, SourceNameSpecifierSchema, StatusPageComponentSchema, StatusPageComponentsSchema, StoredCriteriaSchema, TAGS_ATTRIBUTE_KEY, TAS, TASGraph, TASService, TC_METRIC_CAP, TC_RESERVED_CUSTOM_ATTRIBUTE_KEYS, TC_STANDARD_ATTRIBUTE_KEYS, TICKET_ENRICHMENT_ALARM_TYPES, TICKET_ENRICHMENT_FIELD_CODES, TasAddFlowsFilterSchema, TasAddTransitioningEdgesFilterSchema, TasAddWireContextFilterSchema, TasAddWiresFilterSchema, TasAllFilterSchema, TasAnalyticBaseSchema, TasAnalyticResultSchema, TasAndFilterSchema, TasAttributeAlertStatisticsSchema, TasAttributeFilterModeSchema, TasAttributeFilterSchema, TasAttributeNameSchema, TasAttributeTypeSchema, TasCollectAttributeNamesFilterSchema, TasCollectAttributeNamesResultSchema, TasCollectAttributeResultSchema, TasCollectAttributesFilterSchema, TasCollectCardInfoFilterSchema, TasCollectCardInfoResultSchema, TasCollectCardInfoTierSchema, TasCollectCountsFilterSchema, TasCollectCountsResultSchema, TasCollectExperienceAttributesFilterSchema, TasCollectExperienceSelectorSchema, TasCollectGroupingInfoFilterSchema, TasCollectGroupingInfoResultSchema, TasCollectVertexIdFilterSchema, TasCoverageFilterSchema, TasEdgeSchema, TasEmptyFilterSchema, TasExternalIdSchema, TasFilterSchema, TasFollowPathFilterSchema, TasFollowPathFlowFilterSchema, TasFollowPathTypeSchema, TasGraphSchema, TasGroupingAlertStatisticsSchema, TasGroupingInfoSchema, TasGroupingItemSchema, TasJoinFilterSchema, TasJoinTypeSchema, TasLayerFilterSchema, TasLegacyFilterSchema, TasLuceneFilterSchema, TasNotFilterSchema, TasOrFilterSchema, TasOrderSchema, TasProjectionFilterSchema, TasQuerySchema, TasServiceFilterSchema, TasStatusFilterSchema, TasStoreAttributeValueSchema, TasStoreChangeSchema, TasStoreEdgeSchema, TasStoreGraphInputSchema, TasStoreGraphResponseSchema, TasStoreGraphSchema, TasStoreVertexSchema, TasTakeEdgesFilterSchema, TasTakeFlowsFilterSchema, TasTakeVerticesFilterSchema, TasTraverseFilterSchema, TasVariableFilterSchema, TasVariableSchema, TasVertexIdFilterSchema, TasVertexSchema, TasViewSchema, TemplateDeleteResponseSchema, TemplateWriteBodySchema, TemplateWriteResponseSchema, TenantConfigAttributeSchema, TenantConfigAttributesResponseSchema, TenantConfigAttributesWriteBodySchema, TenantConfigAttributesWriteResponseSchema, TenantProductSchema, TenantProductsResponseSchema, TenantRoleSchema, TenantRolesResponseSchema, TenantService, TicketEnrichmentAlarmFieldSchema, TicketEnrichmentAlarmFieldsResponseSchema, TicketEnrichmentListResponseSchema, TicketEnrichmentMappingSchema, TicketEnrichmentRuleSchema, TicketEnrichmentWriteBodySchema, TicketEnrichmentWriteResponseSchema, TokenCreateResponseSchema, TokenDetailsSchema, TokenGetAndVerifyRequestSchema, TokenMetadataSchema, TokenQueryRequestSchema, TokenQueryResponseSchema, TokenVerifyRequestSchema, Trace, TraversalEdgeFilterSchema, TraversalVertexFilterSchema, TraverseCollectSchema, TraverseDirectionSchema, TraverseSchema, UIM_LOGS_INGESTION_PATH, UpdateAgentTokenRequestSchema, UpdateTenantTokenRequestSchema, UpdateUserTokenRequestSchema, VertexGroupSchema, VertexMappingConfigurationModule, VertexService, VertexStateAlertFilterSchema, VertexStateAllFilterSchema, VertexStateAnalyticResultSchema, VertexStateAndFilterSchema, VertexStateClampSettingSchema, VertexStateCollectVertexGroupStatusFilterSchema, VertexStateEmptyFilterSchema, VertexStateExternalIdInputSchema, VertexStateExternalIdResponseSchema, VertexStateExternalIdSchema, VertexStateFetchRequestSchema, VertexStateFetchResponseSchema, VertexStateFilterSchema, VertexStateGroupResultSchema, VertexStateInputSchema, VertexStateManagementModuleFilterSchema, VertexStateMetricFilterSchema, VertexStateNamespaceFilterSchema, VertexStateNumericIdSchema, VertexStateOrFilterSchema, VertexStateProjectionSchema, VertexStateRangeRequestSchema, VertexStateRangeResponseSchema, VertexStateRepublishRequestSchema, VertexStateResponseItemSchema, VertexStateSchema, VertexStateStateFilterSchema, VertexStateStoreRequestSchema, VertexStateStoreResponseSchema, VertexStateVertexIdFilterSchema, VertexStatusChanges, ViewAccessEntrySchema, ViewAccessRoleSchema, ViewAccessSchema, ViewActiveFilterSchema, ViewAllFilterSchema, ViewAndFilterSchema, ViewAttributeExpressionSchema, ViewAttributeFilterSchema, ViewAttributesSchema, ViewBodySchema, ViewFilterSchema, ViewIdFilterSchema, ViewListResponseSchema, ViewNassSpecSchema, ViewOrFilterSchema, ViewOwnerSchema, ViewQueryRequestSchema, ViewQueryResponseSchema, ViewResponseSchema, ViewSearchRequestSchema, ViewSpecsSchema, ViewTasSpecSchema, WebhookAuthDetailsSchema, WebhookChannelSchema, WebhookSpecSchema, WebhookTestInputSchema, WebhookTestRequestSchema, WebhookTestResponseSchema, ags, agsresponse, alarmFilterDisplayColumnsFor, alarmRecordTime, alertsForSliIndex, algorithmicSituationsEnabled, allAlarmQueues, apiTokenCreate, apiTokenDelete, apiTokenGet, apiTokenList, apiTokenUpdate, appendSli, appendSloTriplet, attributeFilterTargets, authHeaderValue, buildAlarmFilterUpdateBody, buildAlarmQueueFilterExpression, buildAlarmQueueUpdateBody, buildAlertEntry, buildClusteringPolicyUpdateBody, buildCustomLogPayload, buildEnrichmentRuleUpdateBody, buildInventoryCustomFilter, buildInventoryQueueUpdateBody, buildPolicyFilterExpression, buildSliFunction, buildSloTriplet, buildTemplateRefs, buildUimLogPayload, capVertexDetail, checkGet, chunkPayloads, classifyIngestionError, compileTcSourceName, composeMetricTypeBits, contactActivate, contactDelete, contactTestSend, contactsBlockDelete, contactsBlockPut, contactsConfirm, contactsCreate, contactsGet, contactsGetDetail, contactsReplaceNotificationsWith, contactsRequestConfirmationCode, contactsUpdate, convertLegacyConfiguration, createCurlCommand, createCurlScript, createPostmanRequest, createServiceMonolith, customAttributeKeyIssues, decodeMetricTypeBits, defaultItsmPropertyList, defaultRuleName, deriveSliAs, deriveVertexName, describeClusteringCriteria, displayColumnsFor, dottedFileSlot, draftKey, encodeItsmSecret, ensureParallelAlerts, escapeRegExp, evaluate, evaluateTemplate, example, excludedAttributes, exportAlarmRecords, exportFileLabel, exportIncludesToken, expressionPipelineNames, extractComponentGridData, findAlertByTarget, findInventoryGroup, findProduct, findRedactedSecretPaths, findSliByName, flattenAxiosHeaders, folderAccessGet, folderDelete, folderGet, folderPost, folderUpdate, foldersList, formExternalId, getDataStoreSchema, getUserTokenSub, getUserTokenTid, getVertexAttributeValue, getVertexAttributeValueOrNull, hasTypeTagsFlag, hasVertexAttribute, impliedDxo2Version, incrementVariant, inventoryDisplayColumnsFor, inventoryQueuesOf, inventorySearchRequestBodyExample, inventorySearchResponseBody, isAlarmFilter, isAlarmQueue, isAlarmQueueNotFound, isAuthorizationHeader, isBuiltInClusteringPolicy, isBuiltInPolicy, isBuiltInTemplate, isDataStoreSchemaType, isEmptyCriteria, isInventoryQueueNotFound, isPersonalQueue, isProductProvisioned, isTemplate, isTenantToken, isUserToken, isWildcardOnlySourceName, itsmMapToProperties, itsmPropertiesToMap, javaFullMatch, javaRegexToJs, javaReplaceAll, javaReplaceFirst, javaSplit, lintSourceName, listDataStoreSchemaOps, listNameSpecifierOps, listSlis, locationsCreate, locationsDelete, locationsGet, locationsGetAll, locationsGetByType, locationsLeafGetFilter, locationsPost, logGet, logGetEvent, logIngestionURLForGateway, maintenanceDelete, maintenanceDeleteWindows, maintenanceFilter, maintenanceGet, maintenanceGetDetail, maintenanceGetWindows, maintenanceGetWindowsDetail, maintenanceUpdateWindowsDetail, maintenancesCreate, maintenancesImmediateDelete, maintenancesImmediatePut, maintenancesPostWindows, maintenancesUpdate, markServiceMetricPresence, measureBytes, messageGet, messageTemplateVariables, messagesList, monitorActivate, monitorCreate, monitorDeactivate, monitorDelete, monitorGet, monitorGetAll, monitorUpdate, normalizeAlarmQueueSharing, oauthClientTokensCreate, oauthClientTokensDelete, oauthClientTokensGet, oauthClientTokensList, oauthClientTokensUpdate, oauthCreateToken, oauthGetRefreshTokenList, oauthGetTokenList, oauthRefreshTokenDeleteId, oauthTokenCognateDelete, oauthTokenCognateDeleteCurrent, oauthTokenDelete, oauthTokenDeleteCurrent, orBlocksByField, parseAlarmRecordTime, parseExpression, parseExternalIdFormat, parseFilter, parseSaasGateway, parseServiceNowUrl, pipeGroupRanges, planEnrichmentReorder, policyCategoryGuard, policyFieldBounds, policyFilterAtoms, producedMetricName, projectCustomAttributes, projectRule, pruneOrphanSloFunctions, readLifecyclePages, redactChannelSecrets, reencodeItsmForWrite, removeAlert, removeSli, removeSloTriplet, resolveAnomalyDetectionProduct, resolveEnrichmentMappings, resolveWebhookPayload, sampleServiceDetailRequestBody, searchAlarmWindows, searchUniverse, sendWithRetry, serviceDetailResponseBody, settingsGet, settingsGetDetail, settingsUpdate, sharedRoleDelta, sleep, sliHumanName, sloTripletFor, sortRulesByPriority, sourceNameBattery, sourceNameMatrix, splitAttributePath, splitTemplate, standardVertexAttributes, stationDelete, stationsAgentType, stationsCreate, stationsDeleteMaintenance, stationsGet, stationsGetAgents, stationsLatest, stationsList, stationsOnpremiseConnected, stationsOnpremiseConnectedAll, stationsOnpremiseList, stationsPutMaintenance, stationsUpdate, statistic, summarizeDataStoreSchema, tagsGetAll, tcSourceNameMatches, tcSourceNameToJavaRegex, tcSourceNameToMmPattern, templateUsage, tenantConfigAttribute, timezonesList, toAlarmFilterWriteBody, toAlarmQueueWriteBody, toAnomalyDetectionGroupSaveRequest, toAnomalyGroupMetricsRequest, toChannelWriteBody, toClusteringPolicyPreviewBody, toClusteringPolicyWriteBody, toEnrichmentRuleCreateBody, toGroupMetricsRequest, toInventoryQueueWriteBody, toItsmTestConnectionRequest, toPolicyWriteBody, toSliGroupSaveRequest, toTemplateWriteBody, toTicketEnrichmentWriteBody, tokenize, translateRuleToMmQuery, truthy, userBlockDelete, userBlockPut, userDelete, userGet, userLockDelete, userPut, userSubaccountsGet, userSubaccountsPost, verifyAndDumpLegacyConfiguration, verifyAndDumpVersion3Configuration, verifyAndDumpVersion4Configuration, vertexMatchesFilters, visibleAlarmQueueColumns, visibleInventoryColumns };
|
|
90288
91630
|
//# sourceMappingURL=index.esm.js.map
|