@dx-do/client 7.16.0 → 7.17.1

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.
Files changed (27) hide show
  1. package/dist/index.cjs.js +1521 -123
  2. package/dist/index.cjs.js.map +1 -1
  3. package/dist/index.esm.js +1519 -124
  4. package/dist/index.esm.js.map +1 -1
  5. package/dist/src/index.d.ts +3 -0
  6. package/dist/src/index.d.ts.map +1 -1
  7. package/dist/src/lib/model/datastore/datastore-schemas.d.ts +2 -7
  8. package/dist/src/lib/model/datastore/datastore-schemas.d.ts.map +1 -1
  9. package/dist/src/lib/model/datastore/metrics-metadata/attribute-name-specifier.d.ts +2 -2
  10. package/dist/src/lib/model/datastore/metrics-metadata/folder-name-specifier.d.ts +2 -2
  11. package/dist/src/lib/model/datastore/metrics-metadata/source-name-specifier.d.ts +2 -2
  12. package/dist/src/lib/model/datastore/nassql/operations.d.ts.map +1 -1
  13. package/dist/src/lib/model/oi/services.bulk-select.d.ts +109 -0
  14. package/dist/src/lib/model/oi/services.bulk-select.d.ts.map +1 -0
  15. package/dist/src/lib/model/oi/services.bulk.d.ts +243 -0
  16. package/dist/src/lib/model/oi/services.bulk.d.ts.map +1 -0
  17. package/dist/src/lib/model/oi/services.export.d.ts +13 -0
  18. package/dist/src/lib/model/oi/services.export.d.ts.map +1 -1
  19. package/dist/src/lib/model/oi/services.import.d.ts +56 -0
  20. package/dist/src/lib/model/oi/services.import.d.ts.map +1 -0
  21. package/dist/src/lib/model/oi/services.transform.d.ts +10 -1
  22. package/dist/src/lib/model/oi/services.transform.d.ts.map +1 -1
  23. package/dist/src/lib/model/service/service-overview.d.ts +20 -0
  24. package/dist/src/lib/model/service/service-overview.d.ts.map +1 -1
  25. package/dist/src/lib/services/service.service.d.ts +90 -6
  26. package/dist/src/lib/services/service.service.d.ts.map +1 -1
  27. 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()).optional().describe('Exact source name strings; any matching name passes'),
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().optional().describe('Java regex pattern matched against the full source name'),
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()).optional().describe('Exact folder name strings; any matching name passes'),
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().optional().describe('Java regex pattern matched against the full folder name'),
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()).optional().describe('Exact attribute name strings'),
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().optional().describe('Java regex pattern matched against the full attribute name'),
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
- * Java side accepts an empty `columns[]` to clear the grouping ("flatten"
52003
- * pattern); the Zod schema requires `min(1)` so use `--no-validate` if
52004
- * you need that variant.
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
- .min(1)
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
- throw new Error(`Unknown ${type} op "${op}". Valid ops: ${valid.join(', ')}`);
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,950 @@ 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, and whether
64882
+ * it is a single-service export (`service export`, or a bare body of one service and no links),
64883
+ * which carries no child links.
64884
+ * @throws Error when the input is neither shape.
64885
+ */
64886
+ function parseImportFile(raw) {
64887
+ const body = parseImport(raw);
64888
+ const asEnvelope = EnvelopeShape.safeParse(raw);
64889
+ if (!asEnvelope.success) {
64890
+ return { body, singleService: body.vertices.length === 1 && !body.edges.length };
64891
+ }
64892
+ return {
64893
+ body,
64894
+ singleService: asEnvelope.data.kind === 'service',
64895
+ ...(asEnvelope.data.sourceTenant ? { sourceTenant: asEnvelope.data.sourceTenant } : {}),
64896
+ exportedAt: asEnvelope.data.exportedAt,
64897
+ };
64898
+ }
64899
+ ServiceExport.parseImportFile = parseImportFile;
64900
+ })(ServiceExport || (ServiceExport = {}));
64901
+
64902
+ /**
64903
+ * Pure planning for `service import` into any tenant
64904
+ * (docs/internal/service-bulk-save-findings-2026-10.md → "Cross-tenant import"):
64905
+ *
64906
+ * - A service's `metrics` are tenant identity: a save carrying another tenant's (or a
64907
+ * re-created service's stale) metrics is stored verbatim and the server assigns none, so
64908
+ * health, risk and availability point at nothing. Metrics therefore always come from the
64909
+ * target: an existing service keeps its current ones, a new one is sent with `[]`.
64910
+ * - Every saved service is overwritten (attributes and child links), so an import into a
64911
+ * tenant that already has some of the names is a diff to review, not a blind write.
64912
+ */
64913
+ var ServiceImport;
64914
+ (function (ServiceImport) {
64915
+ /** Prefix every service name (and link endpoint) in a body. */
64916
+ function renameBody(body, prefix) {
64917
+ const rename = (n) => `${prefix}${n}`;
64918
+ return {
64919
+ vertices: body.vertices.map((v) => ({
64920
+ ...v,
64921
+ externalId: rename(v.attributes.name),
64922
+ attributes: { ...v.attributes, name: rename(v.attributes.name) },
64923
+ })),
64924
+ edges: body.edges.map((e) => ({
64925
+ ...e,
64926
+ sourceExternalId: rename(e.sourceExternalId),
64927
+ targetExternalId: rename(e.targetExternalId),
64928
+ })),
64929
+ };
64930
+ }
64931
+ ServiceImport.renameBody = renameBody;
64932
+ /**
64933
+ * Plan saving `file` into a target whose current state for the same names is `target`
64934
+ * (missing names = new services).
64935
+ *
64936
+ * @param opts.keepChildren - an existing service the file gives no child links keeps the
64937
+ * target's (a single-service export carries none). Its descendants ride along unchanged,
64938
+ * since a save rejects a link to a service it does not carry.
64939
+ */
64940
+ function planImport(file, target, opts = {}) {
64941
+ const blockers = [];
64942
+ const names = new Set(file.vertices.map((v) => v.attributes.name));
64943
+ const dangling = file.edges.filter((e) => !names.has(e.sourceExternalId) || !names.has(e.targetExternalId));
64944
+ if (dangling.length) {
64945
+ blockers.push(`links to services not in the file: ${dangling.map((e) => `${e.sourceExternalId}→${e.targetExternalId}`).join(', ')}`);
64946
+ }
64947
+ const metricsDropped = [];
64948
+ const metricsKeptFromTarget = [];
64949
+ const vertices = file.vertices.map((v) => {
64950
+ const name = v.attributes.name;
64951
+ const current = target.vertices[name];
64952
+ const fileMetrics = v.attributes.metrics ?? [];
64953
+ if (!current) {
64954
+ if (fileMetrics.length)
64955
+ metricsDropped.push(name);
64956
+ return { ...v, externalId: name, attributes: { ...v.attributes, root_service: null, metrics: [] } };
64957
+ }
64958
+ const targetMetrics = current.attributes.metrics ?? [];
64959
+ if (JSON.stringify(fileMetrics) !== JSON.stringify(targetMetrics))
64960
+ metricsKeptFromTarget.push(name);
64961
+ return { ...v, externalId: name, attributes: { ...v.attributes, root_service: null, metrics: targetMetrics } };
64962
+ });
64963
+ const childrenKept = [];
64964
+ const keptEdges = [];
64965
+ if (opts.keepChildren) {
64966
+ for (const name of names) {
64967
+ if (!target.vertices[name] || file.edges.some((e) => e.sourceExternalId === name))
64968
+ continue;
64969
+ const kids = ServiceTransform.childEdges(target.edges, name);
64970
+ if (!kids.length)
64971
+ continue;
64972
+ keptEdges.push(...kids);
64973
+ childrenKept.push({ service: name, children: kids.map((e) => e.targetExternalId).sort() });
64974
+ }
64975
+ }
64976
+ const carried = ServiceBulk.descendantClosure(target, keptEdges.map((e) => e.targetExternalId))
64977
+ .filter((n) => !names.has(n))
64978
+ .sort();
64979
+ const inPayload = new Set([...names, ...carried]);
64980
+ const carriedEdges = target.edges.filter((e) => carried.includes(e.sourceExternalId));
64981
+ const leaving = carriedEdges.filter((e) => !inPayload.has(e.targetExternalId));
64982
+ if (leaving.length) {
64983
+ blockers.push(`kept links lead outside the target's read: ${leaving.map((e) => `${e.sourceExternalId}→${e.targetExternalId}`).join(', ')}`);
64984
+ }
64985
+ const body = {
64986
+ vertices: [...vertices, ...carried.flatMap((n) => target.vertices[n] ?? [])],
64987
+ edges: [...file.edges, ...keptEdges, ...carriedEdges],
64988
+ };
64989
+ for (const parent of names) {
64990
+ try {
64991
+ ServiceTransform.assertWeightsWithinLimit(file.edges, parent);
64992
+ }
64993
+ catch (e) {
64994
+ blockers.push(`'${parent}': ${e.message}`);
64995
+ }
64996
+ }
64997
+ const after = {
64998
+ vertices: { ...target.vertices, ...Object.fromEntries(vertices.map((v) => [v.attributes.name, v])) },
64999
+ edges: [...target.edges.filter((e) => !names.has(e.sourceExternalId)), ...file.edges, ...keptEdges],
65000
+ };
65001
+ const diff = ServiceBulk.diffGraphs(target, after).filter((d) => names.has(d.service));
65002
+ const created = diff.filter((d) => d.status === 'created').map((d) => d.service).sort();
65003
+ const overwritten = diff.filter((d) => d.status === 'changed');
65004
+ const unchanged = [...names].filter((n) => target.vertices[n] && !overwritten.some((d) => d.service === n)).sort();
65005
+ return {
65006
+ body,
65007
+ created,
65008
+ overwritten,
65009
+ unchanged,
65010
+ metricsDropped: metricsDropped.sort(),
65011
+ metricsKeptFromTarget: metricsKeptFromTarget.sort(),
65012
+ blockers,
65013
+ childrenKept,
65014
+ carried,
65015
+ };
65016
+ }
65017
+ ServiceImport.planImport = planImport;
65018
+ /** Stable short hash of what an import would change; the apply must present it when overwriting. */
65019
+ function importToken(plan) {
65020
+ return cyrb53(JSON.stringify({ created: plan.created, overwritten: plan.overwritten }))
65021
+ .toString(16)
65022
+ .padStart(14, '0')
65023
+ .slice(0, 10);
65024
+ }
65025
+ ServiceImport.importToken = importToken;
65026
+ })(ServiceImport || (ServiceImport = {}));
65027
+
64092
65028
  var OIService;
64093
65029
  (function (OIService) {
64094
65030
  /** @internal */
@@ -66489,6 +67425,82 @@ const serviceDetailResponseBody = {
66489
67425
  },
66490
67426
  };
66491
67427
 
67428
+ /** How far back a listed service metric counts as published. */
67429
+ const SERVICE_METRIC_PRESENCE_WINDOW_MS = 30 * 86_400_000;
67430
+ /**
67431
+ * Marks each metric a service record lists with `published`: whether the metric store holds it within
67432
+ * {@link SERVICE_METRIC_PRESENCE_WINDOW_MS}. A service record lists `service_availability` for every service, but the
67433
+ * platform computes it only when the service has an `availability` metric configured (measured 2026-10-26 across 108
67434
+ * 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
67435
+ * from the record otherwise spends calls on a metric that does not exist. `service_health` / `service_risk` were
67436
+ * published for all 108.
67437
+ */
67438
+ function markServiceMetricPresence(overview, publishedIds) {
67439
+ const metrics = overview.attributes.metrics ?? [];
67440
+ const configured = metrics.find((m) => m.type === 'availability');
67441
+ const marked = metrics.map((m) => {
67442
+ if (publishedIds.has(m.id))
67443
+ return { ...m, published: true };
67444
+ const note = m.type === 'service_availability' && !configured
67445
+ ? '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.'
67446
+ : m.type === 'service_availability' && configured
67447
+ ? `Not published in the last 30 days, although an availability metric is configured (${configured.attributeName}): that metric may not be reporting.`
67448
+ : 'Not published in the last 30 days: there is no data under this id.';
67449
+ return { ...m, published: false, note };
67450
+ });
67451
+ return { ...overview, attributes: { ...overview.attributes, metrics: marked } };
67452
+ }
67453
+ // export const SERVICE_OVERVIEW_EXAMPLE: ServiceOverviewVertex = {
67454
+ // externalId:
67455
+ // 'SA:AA0725E0-0402-4320-A2B7-407025E9D673:2ee14366-6460-4606-9d5b-fbae9a4100b6',
67456
+ // attributes: {
67457
+ // type: 'saService',
67458
+ // name: 'ACME NetOps Salisbury DC - NetOps-O2',
67459
+ // state: 'ACTIVE',
67460
+ // root_service: ['ACME NetOps Salisbury DC - NetOps-O2'],
67461
+ // serviceContent: [],
67462
+ // tags: [],
67463
+ // location: '',
67464
+ // source: 'OI',
67465
+ // description: '',
67466
+ // createTimestamp: 1744572230371,
67467
+ // timestamp: 1744589912503,
67468
+ // maintenance: false,
67469
+ // situationsIncludeChildServices: false,
67470
+ // restrictSLOOnMaintenance: false,
67471
+ // serviceType: 'service',
67472
+ // customProperties: [],
67473
+ // metrics: [
67474
+ // {
67475
+ // type: 'service_risk',
67476
+ // sourceName: 'OI|SA|SERVICES|ALL',
67477
+ // attributeName: '2ee14366-6460-4606-9d5b-fbae9a4100b6:service_risk',
67478
+ // id: 'f.l-AE-H9B-OopMDK0B',
67479
+ // firstSeen: 1744571774000,
67480
+ // },
67481
+ // {
67482
+ // type: 'service_health',
67483
+ // sourceName: 'OI|SA|SERVICES|ALL',
67484
+ // attributeName: '2ee14366-6460-4606-9d5b-fbae9a4100b6:service_health',
67485
+ // id: '7Nm-AAB-H9B-kB8SIJ0B',
67486
+ // firstSeen: 1744571774000,
67487
+ // },
67488
+ // {
67489
+ // type: 'service_availability',
67490
+ // sourceName: 'OI|SA|SERVICES|ALL',
67491
+ // attributeName:
67492
+ // '2ee14366-6460-4606-9d5b-fbae9a4100b6:service_availability',
67493
+ // id: 'ddm-AAB-H9B-BCFeKK0B',
67494
+ // firstSeen: 1744571774000,
67495
+ // },
67496
+ // ],
67497
+ // customMetrics: [],
67498
+ // },
67499
+ // endTime: 7537103999999,
67500
+ // id: 3330,
67501
+ // startTime: 1744589912513,
67502
+ // };
67503
+
66492
67504
  var SituationLifecycle;
66493
67505
  (function (SituationLifecycle) {
66494
67506
  })(SituationLifecycle || (SituationLifecycle = {}));
@@ -71714,7 +72726,7 @@ var weakSetHas = hasWeakSet ? WeakSet.prototype.has : null;
71714
72726
  var hasWeakRef = typeof WeakRef === 'function' && WeakRef.prototype;
71715
72727
  var weakRefDeref = hasWeakRef ? WeakRef.prototype.deref : null;
71716
72728
  var booleanValueOf = Boolean.prototype.valueOf;
71717
- var objectToString = Object.prototype.toString;
72729
+ var objectToString$1 = Object.prototype.toString;
71718
72730
  var functionToString = Function.prototype.toString;
71719
72731
  var $match = String.prototype.match;
71720
72732
  var $slice = String.prototype.slice;
@@ -72034,7 +73046,7 @@ function has$2(obj, key) {
72034
73046
  }
72035
73047
 
72036
73048
  function toStr$2(obj) {
72037
- return objectToString.call(obj);
73049
+ return objectToString$1.call(obj);
72038
73050
  }
72039
73051
 
72040
73052
  function nameOf(f) {
@@ -72615,6 +73627,23 @@ var setMaxIndex = function setMaxIndex(obj, maxIndex) {
72615
73627
  overflowChannel.set(obj, maxIndex);
72616
73628
  };
72617
73629
 
73630
+ // Track containers produced by a `strictMerge` conflict wrap, and their current max numeric index,
73631
+ // so repeated conflicts on one path append instead of nesting a new wrapper each time
73632
+ var conflictChannel = getSideChannel$1();
73633
+
73634
+ var markConflict = function markConflict(obj, maxIndex) {
73635
+ conflictChannel.set(obj, maxIndex);
73636
+ return obj;
73637
+ };
73638
+
73639
+ var isConflict = function isConflict(obj) {
73640
+ return conflictChannel.has(obj);
73641
+ };
73642
+
73643
+ var getConflictIndex = function getConflictIndex(obj) {
73644
+ return conflictChannel.get(obj);
73645
+ };
73646
+
72618
73647
  var hexTable = (function () {
72619
73648
  var array = [];
72620
73649
  for (var i = 0; i < 256; ++i) {
@@ -72667,6 +73696,30 @@ var setProperty = function setProperty(obj, key, value) {
72667
73696
  }
72668
73697
  };
72669
73698
 
73699
+ var maxNumericIndex = function maxNumericIndex(obj, min) {
73700
+ var max = min;
73701
+ var keys = Object.keys(obj);
73702
+ for (var i = 0; i < keys.length; ++i) {
73703
+ var num = parseInt(keys[i], 10);
73704
+ if (String(num) === keys[i] && num > max) {
73705
+ max = num;
73706
+ }
73707
+ }
73708
+
73709
+ return max;
73710
+ };
73711
+
73712
+ var limitedPair = function limitedPair(first, second, options) {
73713
+ var pair = [first, second];
73714
+ if (options && typeof options.arrayLimit === 'number' && pair.length > options.arrayLimit) {
73715
+ if (options.throwOnLimitExceeded) {
73716
+ throw new RangeError('Array limit exceeded. Only ' + options.arrayLimit + ' element' + (options.arrayLimit === 1 ? '' : 's') + ' allowed in an array.');
73717
+ }
73718
+ return markOverflow(arrayToObject(pair, options), 1);
73719
+ }
73720
+ return pair;
73721
+ };
73722
+
72670
73723
  var merge = function merge(target, source, options) {
72671
73724
  /* eslint no-param-reassign: 0 */
72672
73725
  if (!source) {
@@ -72689,8 +73742,20 @@ var merge = function merge(target, source, options) {
72689
73742
  var newIndex = getMaxIndex(target) + 1;
72690
73743
  target[newIndex] = source;
72691
73744
  setMaxIndex(target, newIndex);
73745
+ } else if (options && options.strictMerge && isConflict(target)) {
73746
+ var nextConflict = getConflictIndex(target) + 1;
73747
+ if (
73748
+ options.throwOnLimitExceeded
73749
+ && typeof options.arrayLimit === 'number'
73750
+ && nextConflict >= options.arrayLimit
73751
+ ) {
73752
+ throw new RangeError('Array limit exceeded. Only ' + options.arrayLimit + ' element' + (options.arrayLimit === 1 ? '' : 's') + ' allowed in an array.');
73753
+ }
73754
+ target[nextConflict] = source;
73755
+ markConflict(target, nextConflict);
72692
73756
  } else if (options && options.strictMerge) {
72693
- return [target, source];
73757
+ var conflict = limitedPair(target, source, options);
73758
+ return isArray$1(conflict) ? markConflict(conflict, 1) : conflict;
72694
73759
  } else if (
72695
73760
  (options && (options.plainObjects || options.allowPrototypes))
72696
73761
  || !has$1.call(Object.prototype, source)
@@ -72698,7 +73763,7 @@ var merge = function merge(target, source, options) {
72698
73763
  target[source] = true;
72699
73764
  }
72700
73765
  } else {
72701
- return [target, source];
73766
+ return limitedPair(target, source, options);
72702
73767
  }
72703
73768
 
72704
73769
  return target;
@@ -72730,6 +73795,10 @@ var merge = function merge(target, source, options) {
72730
73795
  var mergeTarget = target;
72731
73796
  if (isArray$1(target) && !isArray$1(source)) {
72732
73797
  mergeTarget = arrayToObject(target, options);
73798
+ if (isConflict(target)) {
73799
+ // the array may have grown past its last conflict, so continue after its last index
73800
+ markConflict(mergeTarget, target.length - 1);
73801
+ }
72733
73802
  }
72734
73803
 
72735
73804
  if (isArray$1(target) && isArray$1(source)) {
@@ -72764,7 +73833,7 @@ var merge = function merge(target, source, options) {
72764
73833
  }
72765
73834
 
72766
73835
  if (isOverflow(source) && !isOverflow(acc)) {
72767
- markOverflow(acc, getMaxIndex(source));
73836
+ markOverflow(acc, maxNumericIndex(acc, getMaxIndex(source)));
72768
73837
  }
72769
73838
  if (isOverflow(acc)) {
72770
73839
  var keyNum = parseInt(key, 10);
@@ -72772,6 +73841,12 @@ var merge = function merge(target, source, options) {
72772
73841
  setMaxIndex(acc, keyNum);
72773
73842
  }
72774
73843
  }
73844
+ if (isConflict(acc)) {
73845
+ var conflictKey = parseInt(key, 10);
73846
+ if (String(conflictKey) === key && conflictKey > getConflictIndex(acc)) {
73847
+ markConflict(acc, conflictKey);
73848
+ }
73849
+ }
72775
73850
 
72776
73851
  return acc;
72777
73852
  }, mergeTarget);
@@ -72785,6 +73860,13 @@ var assign = function assignSingleSource(target, source) {
72785
73860
  };
72786
73861
 
72787
73862
  var decode = function (str, defaultDecoder, charset) {
73863
+ // With no `%` there is no escape to expand, in either charset: `unescape` has
73864
+ // nothing to match, and `decodeURIComponent` is the identity on such a string
73865
+ // (and cannot throw). So only `+` -> ' ' remains, and often not even that.
73866
+ if (typeof str === 'string' && str.indexOf('%') === -1) {
73867
+ return str.indexOf('+') === -1 ? str : str.replace(/\+/g, ' ');
73868
+ }
73869
+
72788
73870
  var strWithoutPlus = str.replace(/\+/g, ' ');
72789
73871
  if (charset === 'iso-8859-1') {
72790
73872
  // unescape never throws, no try...catch needed:
@@ -72798,6 +73880,57 @@ var decode = function (str, defaultDecoder, charset) {
72798
73880
  }
72799
73881
  };
72800
73882
 
73883
+ var hasToPrimitive = typeof Symbol === 'function' && typeof Symbol.toPrimitive === 'symbol';
73884
+ var arrayJoin = Array.prototype.join;
73885
+ var arrayToString = Array.prototype.toString;
73886
+ var objectToString = Object.prototype.toString;
73887
+
73888
+ // an object with no callable toString (eg, from JSON, or null-prototype) would make String() or join() throw,
73889
+ // so it becomes its primitive valueOf or else Object.prototype.toString; arrays are walked like join walks them,
73890
+ // copied only once an element changes, with an array already being joined becoming '' as engines do for cycles
73891
+ var toCoercible = function toCoercible(value, joining) {
73892
+ if (!value || (typeof value !== 'object' && typeof value !== 'function')) {
73893
+ return value;
73894
+ }
73895
+ if (hasToPrimitive && value[Symbol.toPrimitive] != null) {
73896
+ return value;
73897
+ }
73898
+ if (isArray$1(value) && value.toString === arrayToString && value.join === arrayJoin) {
73899
+ var ancestors = joining || getSideChannel$1();
73900
+ if (ancestors.has(value)) {
73901
+ return '';
73902
+ }
73903
+ ancestors.set(value, true);
73904
+ var copy;
73905
+ for (var i = 0; i < value.length; i += 1) {
73906
+ var item = value[i];
73907
+ var coerced = toCoercible(item, ancestors);
73908
+ if (!copy && coerced !== item) {
73909
+ copy = [];
73910
+ for (var j = 0; j < i; j += 1) {
73911
+ copy[j] = value[j];
73912
+ }
73913
+ }
73914
+ if (copy) {
73915
+ copy[i] = coerced;
73916
+ }
73917
+ }
73918
+ ancestors['delete'](value);
73919
+ return copy || value;
73920
+ }
73921
+ if (typeof value.toString === 'function') {
73922
+ return value;
73923
+ }
73924
+ var valueOf = value.valueOf;
73925
+ if (typeof valueOf === 'function') {
73926
+ var primitive = valueOf.call(value);
73927
+ if (!primitive || (typeof primitive !== 'object' && typeof primitive !== 'function')) {
73928
+ return String(primitive);
73929
+ }
73930
+ }
73931
+ return objectToString.call(value);
73932
+ };
73933
+
72801
73934
  var limit = 1024;
72802
73935
 
72803
73936
  /* eslint operator-linebreak: [2, "before"] */
@@ -72813,13 +73946,15 @@ var encode = function encode(str, defaultEncoder, charset, kind, format) {
72813
73946
  if (typeof str === 'symbol') {
72814
73947
  string = Symbol.prototype.toString.call(str);
72815
73948
  } else if (typeof str !== 'string') {
72816
- string = String(str);
73949
+ string = String(toCoercible(str));
72817
73950
  }
72818
73951
 
72819
73952
  if (charset === 'iso-8859-1') {
73953
+ // `escape` leaves `+` untouched, but a literal `+` is decoded back to a space,
73954
+ // so it must be percent-encoded to round-trip (the utf-8 path already does this).
72820
73955
  return escape(string).replace(/%u[0-9a-f]{4}/gi, function ($0) {
72821
73956
  return '%26%23' + parseInt($0.slice(2), 16) + '%3B';
72822
- });
73957
+ }).replace(/\+/g, '%2B');
72823
73958
  }
72824
73959
 
72825
73960
  var out = '';
@@ -72971,7 +74106,8 @@ var utils$1 = {
72971
74106
  isRegExp: isRegExp,
72972
74107
  markOverflow: markOverflow,
72973
74108
  maybeMap: maybeMap,
72974
- merge: merge
74109
+ merge: merge,
74110
+ toCoercible: toCoercible
72975
74111
  };
72976
74112
 
72977
74113
  var getSideChannel = sideChannel;
@@ -73124,10 +74260,10 @@ var stringify$2 = function stringify(
73124
74260
  // we need to join elements in
73125
74261
  if (encodeValuesOnly && encoder) {
73126
74262
  obj = utils.maybeMap(obj, function (v) {
73127
- return v == null ? v : encoder(v);
74263
+ return v == null ? v : encoder(v, defaults.encoder, charset, 'value', format);
73128
74264
  });
73129
74265
  }
73130
- objKeys = [{ value: obj.length > 0 ? obj.join(',') || null : void undefined }];
74266
+ objKeys = [{ value: obj.length > 0 ? utils.toCoercible(obj).join(',') || null : void undefined }];
73131
74267
  } else if (isArray(filter)) {
73132
74268
  objKeys = filter;
73133
74269
  } else {
@@ -73135,7 +74271,7 @@ var stringify$2 = function stringify(
73135
74271
  objKeys = sort ? keys.sort(sort) : keys;
73136
74272
  }
73137
74273
 
73138
- var encodedPrefix = encodeDotInKeys ? String(prefix).replace(/\./g, '%2E') : String(prefix);
74274
+ var encodedPrefix = String(prefix);
73139
74275
 
73140
74276
  var adjustedPrefix = commaRoundTrip && isArray(obj) && obj.length === 1 ? encodedPrefix + '[]' : encodedPrefix;
73141
74277
 
@@ -73225,7 +74361,7 @@ var normalizeStringifyOptions = function normalizeStringifyOptions(opts) {
73225
74361
  }
73226
74362
 
73227
74363
  var arrayFormat;
73228
- if (opts.arrayFormat in arrayPrefixGenerators) {
74364
+ if (has.call(arrayPrefixGenerators, opts.arrayFormat)) {
73229
74365
  arrayFormat = opts.arrayFormat;
73230
74366
  } else if ('indices' in opts) {
73231
74367
  arrayFormat = opts.indices ? 'indices' : 'repeat';
@@ -83470,6 +84606,92 @@ chain.gen = gen;
83470
84606
  chain.fun = fun;
83471
84607
  chain.dataSource = dataSource;
83472
84608
 
84609
+ // @ts-self-types="./path-matcher.d.ts"
84610
+
84611
+ const DIVERGED = -1,
84612
+ MATCHED = -2;
84613
+
84614
+ const defaultFilter$1 = () => true;
84615
+
84616
+ // Array.prototype.join semantics
84617
+ const toPart = key => (key == null ? '' : '' + key);
84618
+
84619
+ class PathMatcher {
84620
+ constructor(filter, separator = '.') {
84621
+ this.filter = filter;
84622
+ this.separator = separator;
84623
+ this.stateful = true;
84624
+ if (typeof filter == 'string') {
84625
+ this.filterWithSeparator = filter + separator;
84626
+ this.states = [0];
84627
+ return;
84628
+ }
84629
+ if (filter instanceof RegExp) {
84630
+ this.paths = [''];
84631
+ this.extend = this._extendRegExp;
84632
+ this.test = this._testRegExp;
84633
+ this.testRecorded = this._testRecordedRegExp;
84634
+ return;
84635
+ }
84636
+ this.stateful = false;
84637
+ this.extend = this._extendNothing;
84638
+ this.test = this.testRecorded = typeof filter == 'function' ? filter : defaultFilter$1;
84639
+ }
84640
+
84641
+ extend(stack) {
84642
+ const length = stack.length;
84643
+ if (length) this.states[length] = this._step(this.states[length - 1], stack[length - 1], length === 1);
84644
+ }
84645
+
84646
+ test(stack, _chunk) {
84647
+ const length = stack.length;
84648
+ return this._isMatch(length ? this._step(this.states[length - 1], stack[length - 1], length === 1) : 0);
84649
+ }
84650
+
84651
+ testRecorded(stack) {
84652
+ return this._isMatch(this.states[stack.length]);
84653
+ }
84654
+
84655
+ _isMatch(state) {
84656
+ return state === MATCHED || state === this.filter.length;
84657
+ }
84658
+
84659
+ // state: a position when the path is a proper prefix of filter + separator
84660
+ _step(state, key, isRoot) {
84661
+ if (!isRoot) state = this._append(state, this.separator);
84662
+ return this._append(state, toPart(key));
84663
+ }
84664
+
84665
+ _append(state, part) {
84666
+ if (state < 0) return state;
84667
+ const filterWithSeparator = this.filterWithSeparator;
84668
+ if (part.length < filterWithSeparator.length - state) return filterWithSeparator.startsWith(part, state) ? state + part.length : DIVERGED;
84669
+ return part.startsWith(filterWithSeparator.slice(state)) ? MATCHED : DIVERGED;
84670
+ }
84671
+
84672
+ _extendRegExp(stack) {
84673
+ const length = stack.length;
84674
+ // kept flat: a test against a concatenated parent costs ~34x more at depth 1000 (nano-bench)
84675
+ if (length) this.paths[length] = length === 1 ? toPart(stack[0]) : [this.paths[length - 1], this.separator, toPart(stack[length - 1])].join('');
84676
+ }
84677
+
84678
+ _testRegExp(stack, _chunk) {
84679
+ const length = stack.length,
84680
+ filter = this.filter;
84681
+ filter.lastIndex = 0;
84682
+ if (!length) return filter.test('');
84683
+ return filter.test(length === 1 ? toPart(stack[0]) : this.paths[length - 1] + this.separator + toPart(stack[length - 1]));
84684
+ }
84685
+
84686
+ _testRecordedRegExp(stack) {
84687
+ const filter = this.filter;
84688
+ filter.lastIndex = 0;
84689
+ return filter.test(this.paths[stack.length]);
84690
+ }
84691
+
84692
+ _extendNothing(_stack) {}
84693
+ }
84694
+
83473
84695
  // @ts-self-types="./filter-base.d.ts"
83474
84696
 
83475
84697
 
@@ -83496,21 +84718,6 @@ const defaultFilter = () => true;
83496
84718
 
83497
84719
  const DEFAULT_MAX_DEPTH = 1024;
83498
84720
 
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
84721
  /** @type {any} */
83515
84722
  const filterBase =
83516
84723
  (
@@ -83525,17 +84732,14 @@ const filterBase =
83525
84732
  const once = options?.once,
83526
84733
  separator = options?.pathSeparator || '.',
83527
84734
  maxDepth = options?.maxDepth ?? DEFAULT_MAX_DEPTH;
83528
- /** @type {(stack: any[], chunk?: any) => boolean} */
84735
+ // the filter as authored: a string or a RegExp is matched by PathMatcher, never called
84736
+ /** @type {((stack: any[], chunk?: any) => boolean) | string | RegExp} */
83529
84737
  let filter = defaultFilter;
83530
84738
  let streamKeys = false,
83531
84739
  mirrorStreamKeys = true;
83532
84740
  if (options) {
83533
- if (typeof options.filter == 'function') {
84741
+ if (typeof options.filter == 'function' || typeof options.filter == 'string' || options.filter instanceof RegExp) {
83534
84742
  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
84743
  }
83540
84744
  if ('streamValues' in options) {
83541
84745
  streamKeys = options.streamValues;
@@ -83546,7 +84750,8 @@ const filterBase =
83546
84750
  mirrorStreamKeys = false;
83547
84751
  }
83548
84752
  }
83549
- const sanitizedOptions = {...options, filter, streamKeys, separator};
84753
+ const sanitizedOptions = {...options, filter, streamKeys, separator},
84754
+ matcher = new PathMatcher(options?.filter, separator);
83550
84755
  let state = 'check',
83551
84756
  stack = [],
83552
84757
  depth = 0,
@@ -83675,7 +84880,7 @@ const filterBase =
83675
84880
  let action = nonCheckableAction;
83676
84881
  if (checkableTokens[chunk.name] === 1) {
83677
84882
  if (stack.length > maxDepth) throw new RangeError(`filter: JSON nesting depth exceeds maxDepth (${maxDepth})`);
83678
- action = filter(stack, chunk) ? specialAction : defaultAction;
84883
+ action = matcher.test(stack, chunk) ? specialAction : defaultAction;
83679
84884
  }
83680
84885
 
83681
84886
  endToken = stopTokens[chunk.name] || '';
@@ -83724,9 +84929,11 @@ const filterBase =
83724
84929
  // update the stack
83725
84930
  switch (chunk.name) {
83726
84931
  case 'startObject':
84932
+ matcher.extend(stack);
83727
84933
  stack.push(null);
83728
84934
  break;
83729
84935
  case 'startArray':
84936
+ matcher.extend(stack);
83730
84937
  stack.push(-1);
83731
84938
  break;
83732
84939
  case 'endObject':
@@ -87945,36 +89152,224 @@ class ServiceService {
87945
89152
  return this.dxSaaSService.oiPost('oi/v2/sa/saTopologyGraph', { serviceName, startTime: Date.now(), endTime: Date.now() });
87946
89153
  }
87947
89154
  /**
87948
- * Builds a faithful, re-postable store body for a service's entire subtree:
87949
- * topology for structure + a per-vertex {@link getService} for full attributes
87950
- * (serviceContent, tags, customProperties, metrics). Shared by
87951
- * `export-hierarchy`, `associate`, and `dissociate`.
89155
+ * Builds a faithful, re-postable store body for a service's entire subtree
89156
+ * (full attributes + association edges) from one hierarchy read. Shared by
89157
+ * `export-hierarchy`, `associate`, `dissociate` and `update-service`.
87952
89158
  *
87953
- * @remarks One GET per vertex — fine for typical (small) hierarchies; reads
87954
- * are not throttled like saves.
89159
+ * @throws Error if the service does not exist.
87955
89160
  */
87956
89161
  async buildHierarchyBody(rootName) {
87957
- const topo = await this.getServiceTopology(rootName);
87958
- const names = new Set([rootName]);
87959
- topo.vertices.forEach((v) => names.add(v.attributes.name));
87960
- const vertices = [];
87961
- const seen = new Set();
89162
+ const graph = await this.readServiceGraph([rootName]);
89163
+ return ServiceBulk.subtreeBody(graph, rootName);
89164
+ }
89165
+ /**
89166
+ * Reads every hierarchy that contains the named services into one name-keyed
89167
+ * graph: one `GET oi/v2/sa/services/{name}?subservices=true` per service not
89168
+ * already covered by an earlier read (the endpoint returns whole hierarchies
89169
+ * from their top-level services down, full attributes included).
89170
+ *
89171
+ * @param opts.allowMissing - skip services that do not exist instead of throwing.
89172
+ * @throws Error if a service does not exist, or a read is paged.
89173
+ */
89174
+ async readServiceGraph(names, opts = {}) {
89175
+ let graph = { vertices: {}, edges: [] };
87962
89176
  for (const name of names) {
87963
- const full = await this.getService(name, false);
87964
- const fv = full.vertices[0];
87965
- if (fv && !seen.has(fv.externalId)) {
87966
- seen.add(fv.externalId);
87967
- vertices.push(ServiceTransform.retrievedToServiceVertex(fv));
89177
+ if (graph.vertices[name])
89178
+ continue;
89179
+ let read;
89180
+ try {
89181
+ read = await this.getService(name, true);
87968
89182
  }
89183
+ catch (e) {
89184
+ if (e.httpCode !== 404)
89185
+ throw e;
89186
+ if (opts.allowMissing)
89187
+ continue;
89188
+ throw new Error(`No service with name '${name}' found`);
89189
+ }
89190
+ graph = ServiceBulk.mergeGraphs(graph, ServiceBulk.graphFromRead(read));
87969
89191
  }
87970
- // Drop edges that reference vertices outside this subtree (e.g. the incoming
87971
- // edge from the root's parent, which saTopologyGraph returns without the
87972
- // parent vertex). Re-posting such a dangling edge is rejected by the server.
87973
- const presentIds = new Set(vertices
87974
- .map((v) => v.externalId)
87975
- .filter((id) => id !== undefined));
87976
- const edges = ServiceTransform.filterEdgesToVertices(ServiceTransform.edgesFromTopology(topo), presentIds);
87977
- return { vertices, edges };
89192
+ return graph;
89193
+ }
89194
+ /**
89195
+ * Plans changes to any number of services, in any hierarchies, without
89196
+ * saving: reads what the changes name, applies them, and returns the
89197
+ * per-service diff, the services the save would carry, and the store body.
89198
+ *
89199
+ * @throws ZodError for malformed changes; Error for an invalid change or
89200
+ * weights over 100 %.
89201
+ */
89202
+ async planServiceChanges(changes) {
89203
+ const parsed = ServiceBulk.parseChanges(changes);
89204
+ const targets = ServiceBulk.targetsOf(parsed);
89205
+ const graph = await this.readServiceGraph(targets);
89206
+ return ServiceBulk.planChanges(graph, targets, parsed);
89207
+ }
89208
+ /**
89209
+ * Previews one set of edits applied to every service a selector picks, saving
89210
+ * nothing. Candidates come from `services` / `root` when given, otherwise from
89211
+ * the services list; every criterion is then re-checked against the fresh
89212
+ * hierarchy read the save would be built from. Edits that would change
89213
+ * nothing on a service are reported, not emitted.
89214
+ *
89215
+ * @param opts.max - more services to change than this is a blocker (default 25).
89216
+ * @throws ZodError for a malformed selector or edits; Error when nothing matches
89217
+ * or a named service does not exist.
89218
+ */
89219
+ async planBulkUpdate(selector, edits, opts = {}) {
89220
+ const sel = ServiceBulkSelect.ServiceSelectorSchema.parse(selector);
89221
+ const edit = ServiceBulkSelect.BulkEditSchema.parse(edits);
89222
+ const max = opts.max ?? 25;
89223
+ let graph = { vertices: {}, edges: [] };
89224
+ let candidates;
89225
+ if (sel.services) {
89226
+ graph = await this.readServiceGraph(sel.services, { allowMissing: true });
89227
+ const missing = sel.services.filter((n) => !graph.vertices[n]);
89228
+ if (missing.length)
89229
+ throw new Error(await this.unknownServicesMessage(missing));
89230
+ candidates = [...new Set(sel.services)];
89231
+ }
89232
+ if (sel.root) {
89233
+ graph = ServiceBulk.mergeGraphs(graph, await this.readServiceGraph([sel.root]));
89234
+ const scope = ServiceBulkSelect.withinDepth(graph, sel.root, sel.depth);
89235
+ candidates = candidates ? candidates.filter((n) => scope.includes(n)) : scope;
89236
+ }
89237
+ let checked = candidates?.length ?? 0;
89238
+ if (!candidates) {
89239
+ const rows = await this.getAllServices(100);
89240
+ checked = rows.length;
89241
+ candidates = rows
89242
+ .filter((r) => ServiceBulkSelect.matchesFilters(ServiceBulkSelect.subjectFromListRow(r), sel))
89243
+ .map((r) => r.name);
89244
+ graph = await this.readServiceGraph(candidates, { allowMissing: true });
89245
+ }
89246
+ const excluded = [];
89247
+ const matched = candidates.filter((name) => {
89248
+ const v = graph.vertices[name];
89249
+ if (!v) {
89250
+ excluded.push({ service: name, reason: 'no longer exists' });
89251
+ return false;
89252
+ }
89253
+ if (ServiceBulkSelect.matchesFilters(ServiceBulkSelect.subjectFromVertex(v), sel))
89254
+ return true;
89255
+ if (sel.services) {
89256
+ excluded.push({ service: name, reason: 'does not match the other criteria' });
89257
+ }
89258
+ else if (!sel.root) {
89259
+ excluded.push({ service: name, reason: 'no longer matches' });
89260
+ }
89261
+ return false;
89262
+ });
89263
+ if (!matched.length) {
89264
+ throw new Error(`0 of ${checked} services match ${ServiceBulkSelect.describeSelector(sel)}`);
89265
+ }
89266
+ const { changes, outcomes, warnings } = ServiceBulkSelect.expandEdits(graph, matched, edit);
89267
+ const blockers = ServiceBulkSelect.editBlockers(edit);
89268
+ const changing = outcomes.filter((o) => o.will.length).length;
89269
+ if (changing > max) {
89270
+ blockers.push(`${changing} services would change, more than max=${max}; narrow the selector or raise max`);
89271
+ }
89272
+ const planned = changes.length
89273
+ ? ServiceBulk.planChanges(graph, ServiceBulk.targetsOf(changes), changes).plan
89274
+ : { targets: [], changes: [], diff: [], save: [] };
89275
+ const changed = new Set(planned.diff.map((d) => d.service));
89276
+ return {
89277
+ selector: ServiceBulkSelect.describeSelector(sel),
89278
+ checked,
89279
+ matched,
89280
+ outcomes,
89281
+ excluded,
89282
+ warnings,
89283
+ blockers,
89284
+ plan: planned,
89285
+ before: planned.save.length ? ServiceBulk.bodyFor(graph, planned.save) : { vertices: [], edges: [] },
89286
+ carried: planned.save.filter((n) => !changed.has(n)),
89287
+ confirm: ServiceBulkSelect.planToken(planned),
89288
+ };
89289
+ }
89290
+ /** "No service named …", with case-insensitive suggestions from the services list. */
89291
+ async unknownServicesMessage(missing) {
89292
+ const all = (await this.getAllServices(100)).map((s) => s.name);
89293
+ const lines = missing.map((m) => {
89294
+ const near = all.filter((n) => n.toLowerCase() === m.toLowerCase());
89295
+ return near.length ? `'${m}' (did you mean '${near.join("', '")}'?)` : `'${m}'`;
89296
+ });
89297
+ return `No service with name ${lines.join(', ')} found (names are case-sensitive)`;
89298
+ }
89299
+ /**
89300
+ * The tenant's service cap and how many services count against it
89301
+ * (`GET oi/v2/sa/serviceLimitExceeded`).
89302
+ *
89303
+ * @remarks `limitExceeded` is already true when the count equals the limit (the tenant is
89304
+ * full). The count lags deletes by one to three minutes.
89305
+ */
89306
+ async getServiceLimit() {
89307
+ return this.dxSaaSService.oiGet('oi/v2/sa/serviceLimitExceeded');
89308
+ }
89309
+ /**
89310
+ * Plans importing a store body (an export file) into this tenant, saving nothing:
89311
+ * reads the target's current state for every name in the file, takes each service's
89312
+ * metrics from the target ({@link ServiceImport.planImport}), and checks the service cap.
89313
+ *
89314
+ * @param opts.prefix - rename every service in the file first (cloning).
89315
+ */
89316
+ async planImport(file, opts = {}) {
89317
+ const body = opts.prefix ? ServiceImport.renameBody(file, opts.prefix) : file;
89318
+ // The services list lags a create by minutes, so a name it lacks may still exist and
89319
+ // must be checked directly; trusting the list would overwrite that service as new.
89320
+ const listed = new Set((await this.getAllServices(100)).map((s) => s.name));
89321
+ const all = body.vertices.map((v) => v.attributes.name);
89322
+ const { results: unlistedFound } = await dist$1.PromisePool.for(all.filter((n) => !listed.has(n)))
89323
+ .withConcurrency(8)
89324
+ .handleError((e) => {
89325
+ throw e;
89326
+ })
89327
+ .process(async (name) => {
89328
+ try {
89329
+ await this.getService(name, false);
89330
+ return name;
89331
+ }
89332
+ catch (e) {
89333
+ if (e.httpCode !== 404)
89334
+ throw e;
89335
+ return null;
89336
+ }
89337
+ });
89338
+ const names = [...all.filter((n) => listed.has(n)), ...unlistedFound.filter((n) => n !== null)];
89339
+ const target = await this.readServiceGraph(names, { allowMissing: true });
89340
+ const plan = ServiceImport.planImport(body, target, { keepChildren: opts.keepChildren ?? false });
89341
+ const cap = await this.getServiceLimit();
89342
+ const headroom = cap.limit - cap.totalServiceCnt;
89343
+ if (plan.created.length > headroom) {
89344
+ plan.blockers.push(`${plan.created.length} new services but only ${headroom} of ${cap.limit} left under the tenant's service cap`);
89345
+ }
89346
+ return { ...plan, headroom, limit: cap.limit };
89347
+ }
89348
+ /**
89349
+ * Commits a plan in ONE save. Re-reads the plan's services and refuses when a
89350
+ * value the plan replaces has moved; otherwise re-applies the changes onto the
89351
+ * fresh read (so concurrent edits elsewhere are kept) and saves. A plan whose
89352
+ * changes are already in place saves nothing (`response` is absent).
89353
+ *
89354
+ * @param opts.force - skip the conflict check and apply onto whatever is there now.
89355
+ * @throws ServiceBulk.ServiceConflictError listing what moved.
89356
+ * @remarks The server rejects an invalid payload whole — nothing is applied.
89357
+ */
89358
+ async commitServicePlan(plan, opts = {}) {
89359
+ const checked = ServiceBulk.parsePlan(plan);
89360
+ const fresh = await this.readServiceGraph(checked.targets, {
89361
+ allowMissing: true,
89362
+ });
89363
+ if (!opts.force) {
89364
+ const conflicts = ServiceBulk.findConflicts(checked, fresh);
89365
+ if (conflicts.length)
89366
+ throw new ServiceBulk.ServiceConflictError(conflicts);
89367
+ }
89368
+ const rebased = ServiceBulk.planChanges(fresh, checked.targets, checked.changes);
89369
+ if (!rebased.plan.diff.length)
89370
+ return rebased;
89371
+ const response = await this.createService(rebased.body, { replace: true });
89372
+ return { ...rebased, response };
87978
89373
  }
87979
89374
  /** Builds a single-service store body (no edges) for `service export`. */
87980
89375
  async exportServiceBody(serviceName) {
@@ -90284,5 +91679,5 @@ function createServiceMonolith(dxDoConfiguration, log = new NullSimpleLog()) {
90284
91679
  };
90285
91680
  }
90286
91681
 
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 };
91682
+ 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
91683
  //# sourceMappingURL=index.esm.js.map