@dx-do/client 8.0.0 → 9.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (57) hide show
  1. package/dist/index.cjs.js +2283 -174
  2. package/dist/index.cjs.js.map +1 -1
  3. package/dist/index.esm.js +2204 -175
  4. package/dist/index.esm.js.map +1 -1
  5. package/dist/src/index.d.ts +14 -0
  6. package/dist/src/index.d.ts.map +1 -1
  7. package/dist/src/lib/model/alarm/alarm-queue.d.ts +2 -0
  8. package/dist/src/lib/model/alarm/alarm-queue.d.ts.map +1 -1
  9. package/dist/src/lib/model/channel/notify-channel.d.ts +5 -4
  10. package/dist/src/lib/model/channel/notify-channel.d.ts.map +1 -1
  11. package/dist/src/lib/model/dashboard/DashboardResponse.d.ts +12 -3
  12. package/dist/src/lib/model/dashboard/DashboardResponse.d.ts.map +1 -1
  13. package/dist/src/lib/model/oi/alarms.d.ts +14 -0
  14. package/dist/src/lib/model/oi/alarms.d.ts.map +1 -1
  15. package/dist/src/lib/model/oi/custom-properties.d.ts +184 -0
  16. package/dist/src/lib/model/oi/custom-properties.d.ts.map +1 -0
  17. package/dist/src/lib/model/oi/custom-property-grid.d.ts +121 -0
  18. package/dist/src/lib/model/oi/custom-property-grid.d.ts.map +1 -0
  19. package/dist/src/lib/model/oi/custom-property-routing.d.ts +60 -0
  20. package/dist/src/lib/model/oi/custom-property-routing.d.ts.map +1 -0
  21. package/dist/src/lib/model/oi/services.create.d.ts +6 -1
  22. package/dist/src/lib/model/oi/services.create.d.ts.map +1 -1
  23. package/dist/src/lib/model/security/access-references.d.ts +23 -0
  24. package/dist/src/lib/model/security/access-references.d.ts.map +1 -0
  25. package/dist/src/lib/model/security/roles.d.ts +75 -0
  26. package/dist/src/lib/model/security/roles.d.ts.map +1 -0
  27. package/dist/src/lib/model/security/user-groups.d.ts +69 -0
  28. package/dist/src/lib/model/security/user-groups.d.ts.map +1 -0
  29. package/dist/src/lib/model/service/availability-kpi.d.ts +86 -0
  30. package/dist/src/lib/model/service/availability-kpi.d.ts.map +1 -0
  31. package/dist/src/lib/model/situations/SituationLifecycle.d.ts +2 -0
  32. package/dist/src/lib/model/situations/SituationLifecycle.d.ts.map +1 -1
  33. package/dist/src/lib/model/situations/naming-template.d.ts +73 -0
  34. package/dist/src/lib/model/situations/naming-template.d.ts.map +1 -0
  35. package/dist/src/lib/model/situations/situation-explain.d.ts +365 -0
  36. package/dist/src/lib/model/situations/situation-explain.d.ts.map +1 -0
  37. package/dist/src/lib/model/synthetics/access-policy.d.ts +115 -0
  38. package/dist/src/lib/model/synthetics/access-policy.d.ts.map +1 -0
  39. package/dist/src/lib/services/alarm.service.d.ts +4 -2
  40. package/dist/src/lib/services/alarm.service.d.ts.map +1 -1
  41. package/dist/src/lib/services/custom-property.service.d.ts +53 -0
  42. package/dist/src/lib/services/custom-property.service.d.ts.map +1 -0
  43. package/dist/src/lib/services/dashboard.service.d.ts +11 -0
  44. package/dist/src/lib/services/dashboard.service.d.ts.map +1 -1
  45. package/dist/src/lib/services/role.service.d.ts +46 -0
  46. package/dist/src/lib/services/role.service.d.ts.map +1 -0
  47. package/dist/src/lib/services/service-monolith.d.ts +8 -0
  48. package/dist/src/lib/services/service-monolith.d.ts.map +1 -1
  49. package/dist/src/lib/services/service.service.d.ts +40 -0
  50. package/dist/src/lib/services/service.service.d.ts.map +1 -1
  51. package/dist/src/lib/services/situation.service.d.ts +13 -2
  52. package/dist/src/lib/services/situation.service.d.ts.map +1 -1
  53. package/dist/src/lib/services/synthetic-access.service.d.ts +35 -0
  54. package/dist/src/lib/services/synthetic-access.service.d.ts.map +1 -0
  55. package/dist/src/lib/services/user-group.service.d.ts +52 -0
  56. package/dist/src/lib/services/user-group.service.d.ts.map +1 -0
  57. package/package.json +2 -1
package/dist/index.esm.js CHANGED
@@ -3857,7 +3857,7 @@ var EXP_LIMIT = 9e15, // 0 to 9e15
3857
3857
  isOctal = /^0o([0-7]+(\.[0-7]*)?|\.[0-7]+)(p[+-]?\d+)?$/i,
3858
3858
  isDecimal = /^(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i,
3859
3859
 
3860
- BASE$2 = 1e7,
3860
+ BASE$5 = 1e7,
3861
3861
  LOG_BASE = 7,
3862
3862
  MAX_SAFE_INTEGER$2 = 9007199254740991,
3863
3863
 
@@ -5128,9 +5128,9 @@ P$2.minus = P$2.sub = function (y) {
5128
5128
  for (i = yd.length; i > k;) {
5129
5129
 
5130
5130
  if (xd[--i] < yd[i]) {
5131
- for (j = i; j && xd[--j] === 0;) xd[j] = BASE$2 - 1;
5131
+ for (j = i; j && xd[--j] === 0;) xd[j] = BASE$5 - 1;
5132
5132
  --xd[j];
5133
- xd[i] += BASE$2;
5133
+ xd[i] += BASE$5;
5134
5134
  }
5135
5135
 
5136
5136
  xd[i] -= yd[i];
@@ -5359,8 +5359,8 @@ P$2.plus = P$2.add = function (y) {
5359
5359
 
5360
5360
  // Only start adding at yd.length - 1 as the further digits of xd can be left as they are.
5361
5361
  for (carry = 0; i;) {
5362
- carry = (xd[--i] = xd[i] + yd[i] + carry) / BASE$2 | 0;
5363
- xd[i] %= BASE$2;
5362
+ carry = (xd[--i] = xd[i] + yd[i] + carry) / BASE$5 | 0;
5363
+ xd[i] %= BASE$5;
5364
5364
  }
5365
5365
 
5366
5366
  if (carry) {
@@ -5658,11 +5658,11 @@ P$2.times = P$2.mul = function (y) {
5658
5658
  carry = 0;
5659
5659
  for (k = xdL + i; k > i;) {
5660
5660
  t = r[k] + yd[i] * xd[k - i - 1] + carry;
5661
- r[k--] = t % BASE$2 | 0;
5662
- carry = t / BASE$2 | 0;
5661
+ r[k--] = t % BASE$5 | 0;
5662
+ carry = t / BASE$5 | 0;
5663
5663
  }
5664
5664
 
5665
- r[k] = (r[k] + carry) % BASE$2 | 0;
5665
+ r[k] = (r[k] + carry) % BASE$5 | 0;
5666
5666
  }
5667
5667
 
5668
5668
  // Remove trailing zeros.
@@ -6488,7 +6488,7 @@ var divide$1 = (function () {
6488
6488
  logBase = 1;
6489
6489
  e = x.e - y.e;
6490
6490
  } else {
6491
- base = BASE$2;
6491
+ base = BASE$5;
6492
6492
  logBase = LOG_BASE;
6493
6493
  e = mathfloor(x.e / logBase) - mathfloor(y.e / logBase);
6494
6494
  }
@@ -6811,13 +6811,13 @@ var divide$1 = (function () {
6811
6811
  // if i != k the length has increased.
6812
6812
  if (i != k) {
6813
6813
  x.e++;
6814
- if (xd[0] == BASE$2) xd[0] = 1;
6814
+ if (xd[0] == BASE$5) xd[0] = 1;
6815
6815
  }
6816
6816
 
6817
6817
  break;
6818
6818
  } else {
6819
6819
  xd[xdi] += k;
6820
- if (xd[xdi] != BASE$2) break;
6820
+ if (xd[xdi] != BASE$5) break;
6821
6821
  xd[xdi--] = 0;
6822
6822
  k = 1;
6823
6823
  }
@@ -7393,7 +7393,7 @@ function parseOther(x, str) {
7393
7393
  divisor = intPow(Ctor, new Ctor(base), i, i * 2);
7394
7394
  }
7395
7395
 
7396
- xd = convertBase(str, base, BASE$2);
7396
+ xd = convertBase(str, base, BASE$5);
7397
7397
  xe = xd.length - 1;
7398
7398
 
7399
7399
  // Remove trailing zeros.
@@ -12657,6 +12657,10 @@ const AlarmQueueFieldSchema = z.looseObject({
12657
12657
  fieldDescription: z.string().describe('Human label the UI stores next to the field'),
12658
12658
  values: z.array(z.string()).describe('Closed vocabulary when non-empty (e.g. severity levels)'),
12659
12659
  hideMoreOptions: z.boolean().optional().describe('UI hint: no free-text option for this field'),
12660
+ fieldType: z
12661
+ .string()
12662
+ .optional()
12663
+ .describe("'nested' for service_custom_properties: a condition names one property as field `service_custom_properties.<property>`"),
12660
12664
  });
12661
12665
  const AlarmQueueFieldsResponseSchema = z.array(AlarmQueueFieldSchema);
12662
12666
  /** One entry of `GET oi/v2/api/getUserRoles`, the tenant's role catalog. */
@@ -13933,9 +13937,10 @@ function resolveWebhookPayload(fieldNames, catalog) {
13933
13937
  // Template / payload variables (the message-template field catalog)
13934
13938
  // ---------------------------------------------------------------------------
13935
13939
  /**
13936
- * Alarm-type tags on the field catalog. `ALL` = every kind;
13937
- * `SITUATIONS.ALARMS_ALL` = a situation's source-alarm fields
13938
- * (`situation.allAlarm.*`), usable in situation templates.
13940
+ * Alarm-type tags on the field catalog. `ALL` = every kind. Situation templates can also use
13941
+ * `SITUATIONS.ALARMS_ALL` (a situation's source-alarm fields, `situation.allAlarm.*`),
13942
+ * `SITUATIONS.ROOT_CAUSE` (`rc_alarm.*`) and `SITUATIONS.MOST_IMPACTED` (`mostImpacted_alarm.*`):
13943
+ * 170 fields each on the lab (2026-11), including the service attributes.
13939
13944
  */
13940
13945
  const MESSAGE_TEMPLATE_ALARM_TYPES = [
13941
13946
  'ALL',
@@ -13943,11 +13948,13 @@ const MESSAGE_TEMPLATE_ALARM_TYPES = [
13943
13948
  'ALARMS_SERVICE',
13944
13949
  'SITUATIONS',
13945
13950
  'SITUATIONS.ALARMS_ALL',
13951
+ 'SITUATIONS.ROOT_CAUSE',
13952
+ 'SITUATIONS.MOST_IMPACTED',
13946
13953
  ];
13947
13954
  const ALARM_TYPES_BY_CATEGORY = {
13948
13955
  rawAlarm: ['ALL', 'ALARMS_ALL'],
13949
13956
  service: ['ALL', 'ALARMS_SERVICE'],
13950
- situation: ['ALL', 'SITUATIONS', 'SITUATIONS.ALARMS_ALL'],
13957
+ situation: ['ALL', 'SITUATIONS', 'SITUATIONS.ALARMS_ALL', 'SITUATIONS.ROOT_CAUSE', 'SITUATIONS.MOST_IMPACTED'],
13951
13958
  };
13952
13959
  /**
13953
13960
  * The `${field}` placeholders a message template or webhook payload can use,
@@ -38795,6 +38802,733 @@ var OIAlarm;
38795
38802
  OIAlarm.withAlarmTypes = withAlarmTypes;
38796
38803
  })(OIAlarm || (OIAlarm = {}));
38797
38804
 
38805
+ /**
38806
+ * Managed custom service properties (2026-11 release): tenant-level definitions of the
38807
+ * `customProperties` keys services carry, at `oi/v2/sa/customproperties`. Rules measured on
38808
+ * THE_LABORATORY (#1583): the server validates definitions (name pattern, unique name, enum
38809
+ * options, default value), but NOT the values services store: `sa/save` accepts a missing
38810
+ * required key, an enum value outside the list and a non-numeric number. Service values stay
38811
+ * `{name, value}` pairs; keys with no definition ("unmanaged") keep working beside managed ones.
38812
+ */
38813
+ const CUSTOM_PROPERTY_VALUE_TYPES = ['text', 'number', 'url', 'email', 'enum'];
38814
+ const CustomPropertyValueTypeSchema = z
38815
+ .enum(CUSTOM_PROPERTY_VALUE_TYPES)
38816
+ .describe('Value type; the server rejects any other');
38817
+ /** The server's name rule (400 "must start with a letter and contain only letters, digits, and underscores"). */
38818
+ const CUSTOM_PROPERTY_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_]*$/;
38819
+ const CustomPropertyAllowedValueSchema = z.looseObject({
38820
+ value: z.string().describe('One allowed value of an enum property'),
38821
+ usage: z.number().describe('Services holding this value'),
38822
+ });
38823
+ /** One definition as `GET oi/v2/sa/customproperties` lists it. */
38824
+ const CustomPropertyDefinitionSchema = z.looseObject({
38825
+ id: z.string().optional().describe('Equal to name'),
38826
+ name: z.string().describe('Property key, as services store it in customProperties[].name'),
38827
+ description: z.string().optional().describe('Free text'),
38828
+ valueType: z.string().describe("text | number | url | email | enum (read as a string so a new type does not break a read)"),
38829
+ multiValued: z.boolean().optional().describe('Always false so far'),
38830
+ allowedValues: z
38831
+ .array(CustomPropertyAllowedValueSchema)
38832
+ .nullable()
38833
+ .optional()
38834
+ .describe('enum only: the options with per-value usage (written as `options`)'),
38835
+ defaultValue: z.string().optional().describe('Pre-filled on new services; "" for none'),
38836
+ required: z.boolean().describe('New services must carry it (the UI enforces this; sa/save does not)'),
38837
+ usageCount: z.number().optional().describe('Services holding the key'),
38838
+ totalServicesCount: z.number().optional().describe('All services in the tenant'),
38839
+ createdBy: z.string().optional(),
38840
+ createdOn: z.string().optional().describe('ISO time'),
38841
+ updatedBy: z.string().optional(),
38842
+ updatedOn: z.string().optional().describe('ISO time'),
38843
+ });
38844
+ const CustomPropertyDefinitionListSchema = z.array(CustomPropertyDefinitionSchema);
38845
+ /**
38846
+ * Create / update body (`POST oi/v2/sa/customproperties`, `PUT …/{name}` takes the full body).
38847
+ * Mirrors the server's checks so a dry run catches what the server would reject.
38848
+ */
38849
+ const CustomPropertyWriteSchema = z
38850
+ .object({
38851
+ name: z
38852
+ .string()
38853
+ .regex(CUSTOM_PROPERTY_NAME_PATTERN, 'name must start with a letter and contain only letters, digits and underscores')
38854
+ .describe('Property key; immutable after create'),
38855
+ description: z.string().describe('Free text; "" allowed'),
38856
+ valueType: CustomPropertyValueTypeSchema,
38857
+ options: z.array(z.string().min(1)).nullable().describe('enum: the allowed values (non-empty); null otherwise'),
38858
+ defaultValue: z.string().describe('"" for none; must be valid for the type'),
38859
+ required: z.boolean().describe('Whether new services must carry it'),
38860
+ })
38861
+ .superRefine((body, ctx) => {
38862
+ if (body.valueType === 'enum' && (!body.options || body.options.length === 0)) {
38863
+ ctx.addIssue({ code: 'custom', path: ['options'], message: "options is required and cannot be empty when valueType is 'enum'" });
38864
+ }
38865
+ if (body.valueType !== 'enum' && body.options && body.options.length > 0) {
38866
+ ctx.addIssue({ code: 'custom', path: ['options'], message: `options only apply to enum properties, not '${body.valueType}'` });
38867
+ }
38868
+ if (body.defaultValue !== '') {
38869
+ const problem = checkPropertyValue({ valueType: body.valueType, allowedValues: (body.options ?? []).map((value) => ({ value, usage: 0 })) }, body.defaultValue);
38870
+ if (problem)
38871
+ ctx.addIssue({ code: 'custom', path: ['defaultValue'], message: `defaultValue ${problem}` });
38872
+ }
38873
+ });
38874
+ /** `POST` / `PUT` response: the definition as written (times in epoch seconds). */
38875
+ const CustomPropertyWriteResponseSchema = z.looseObject({
38876
+ name: z.string(),
38877
+ valueType: z.string(),
38878
+ options: z.array(z.string()).nullable().optional(),
38879
+ required: z.boolean(),
38880
+ defaultValue: z.string().optional(),
38881
+ CreationTime: z.number().optional().describe('Epoch seconds'),
38882
+ UpdateTime: z.number().optional().describe('Epoch seconds'),
38883
+ });
38884
+ /** `GET …/{name}/usage`: which services hold the key, with their values. An unknown name gives count 0. */
38885
+ const CustomPropertyUsageSchema = z.looseObject({
38886
+ count: z.number().describe('Services holding the key'),
38887
+ name: z.string(),
38888
+ Services: z.record(z.string(), z.string()).describe('service name → stored value'),
38889
+ });
38890
+ const NUMERIC$1 = /^-?(\d+(\.\d*)?|\.\d+)([eE][-+]?\d+)?$/;
38891
+ const EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
38892
+ /**
38893
+ * Why `value` is not valid for the definition, or undefined when it is. The server never
38894
+ * checks stored values, so this is the only check there is. `url` must parse with a scheme.
38895
+ */
38896
+ function checkPropertyValue(definition, value) {
38897
+ switch (definition.valueType) {
38898
+ case 'number':
38899
+ return NUMERIC$1.test(value.trim()) ? undefined : `'${value}' is not a number`;
38900
+ case 'email':
38901
+ return EMAIL.test(value) ? undefined : `'${value}' is not an email address`;
38902
+ case 'url':
38903
+ try {
38904
+ const url = new URL(value);
38905
+ return url.protocol ? undefined : `'${value}' is not a URL`;
38906
+ }
38907
+ catch {
38908
+ return `'${value}' is not a URL`;
38909
+ }
38910
+ case 'enum': {
38911
+ const allowed = (definition.allowedValues ?? []).map((a) => a.value);
38912
+ return allowed.includes(value) ? undefined : `'${value}' is not one of ${allowed.join(', ')}`;
38913
+ }
38914
+ default:
38915
+ return undefined;
38916
+ }
38917
+ }
38918
+ /** The write body that reproduces a listed definition (`allowedValues` → `options`). */
38919
+ function toDefinitionWrite(definition) {
38920
+ return {
38921
+ name: definition.name,
38922
+ description: definition.description ?? '',
38923
+ valueType: definition.valueType,
38924
+ options: definition.valueType === 'enum' ? (definition.allowedValues ?? []).map((a) => a.value) : null,
38925
+ defaultValue: definition.defaultValue ?? '',
38926
+ required: definition.required,
38927
+ };
38928
+ }
38929
+ /** What `propertyCoverage` checks and does not, for scoped negatives. */
38930
+ const PROPERTY_COVERAGE_SCOPE = {
38931
+ checked: [
38932
+ 'every managed definition against every service in scope: key present or missing',
38933
+ "stored values against the definition's type and enum options (the server never checks them)",
38934
+ 'value spellings that differ only in case or whitespace',
38935
+ 'enum options no service holds',
38936
+ 'keys services carry without a definition, with a suggested type and likely misspellings of managed keys',
38937
+ ],
38938
+ notChecked: [
38939
+ 'which notification policies and alarm queues filter on a property (view=routing checks them)',
38940
+ 'inheritance between parent and child services',
38941
+ 'services outside the scope given',
38942
+ ],
38943
+ };
38944
+ const servicePropertyMap = (s) => {
38945
+ const cp = s.customProperties;
38946
+ if (!cp)
38947
+ return new Map();
38948
+ if (Array.isArray(cp))
38949
+ return new Map(cp.map((p) => [p.name, p.value ?? '']));
38950
+ return new Map(Object.entries(cp).map(([k, v]) => [k, v ?? '']));
38951
+ };
38952
+ const normalizeValue$1 = (v) => v.trim().replace(/\s+/g, ' ').toLowerCase();
38953
+ const normalizeKey = (k) => k.toLowerCase().replace(/[\s_-]/g, '');
38954
+ const count = (values) => {
38955
+ const out = {};
38956
+ for (const v of [...values].sort())
38957
+ out[v] = (out[v] ?? 0) + 1;
38958
+ return out;
38959
+ };
38960
+ function valueVariants(values) {
38961
+ const groups = new Map();
38962
+ for (const [value, holders] of Object.entries(values)) {
38963
+ const key = normalizeValue$1(value);
38964
+ groups.set(key, { ...(groups.get(key) ?? {}), [value]: holders });
38965
+ }
38966
+ return [...groups.entries()]
38967
+ .filter(([, spellings]) => Object.keys(spellings).length > 1)
38968
+ .map(([normalized, spellings]) => ({ normalized, spellings }));
38969
+ }
38970
+ function editDistance(a, b) {
38971
+ const row = Array.from({ length: b.length + 1 }, (_, j) => j);
38972
+ for (let i = 1; i <= a.length; i++) {
38973
+ let diagonal = row[0];
38974
+ row[0] = i;
38975
+ for (let j = 1; j <= b.length; j++) {
38976
+ const above = row[j];
38977
+ row[j] = Math.min(above + 1, row[j - 1] + 1, diagonal + (a[i - 1] === b[j - 1] ? 0 : 1));
38978
+ diagonal = above;
38979
+ }
38980
+ }
38981
+ return row[b.length];
38982
+ }
38983
+ function resembles(key, managed) {
38984
+ const k = normalizeKey(key);
38985
+ for (const name of managed) {
38986
+ const m = normalizeKey(name);
38987
+ if (k === m || (k.length >= 5 && m.length >= 5 && editDistance(k, m) <= 2))
38988
+ return name;
38989
+ }
38990
+ return null;
38991
+ }
38992
+ const ENUM_MAX_OPTIONS = 10;
38993
+ function suggestType(values) {
38994
+ const nonEmpty = values.filter((v) => v.trim() !== '');
38995
+ const fits = (valueType) => nonEmpty.length > 0 && nonEmpty.every((v) => checkPropertyValue({ valueType }, v) === undefined);
38996
+ for (const type of ['number', 'email', 'url'])
38997
+ if (fits(type))
38998
+ return { type, options: null };
38999
+ const distinct = [...new Set(nonEmpty)].sort();
39000
+ if (distinct.length >= 2 && distinct.length <= ENUM_MAX_OPTIONS && distinct.length < nonEmpty.length) {
39001
+ return { type: 'enum', options: distinct };
39002
+ }
39003
+ return { type: 'text', options: null };
39004
+ }
39005
+ /**
39006
+ * Coverage of the managed properties over `services`: per definition, who lacks the key, whose
39007
+ * value is invalid, the value distribution and its case/whitespace variants; per service, its
39008
+ * gaps; and the keys services carry without a definition. Pure: the caller reads the definitions
39009
+ * and the service list (the ungrouped service list returns `customProperties` on every service).
39010
+ */
39011
+ function propertyCoverage(definitions, services) {
39012
+ const stored = services.map((s) => ({ name: s.name, props: servicePropertyMap(s) }));
39013
+ const managed = new Set(definitions.map((d) => d.name));
39014
+ const sortedDefinitions = [...definitions].sort((a, b) => a.name.localeCompare(b.name));
39015
+ const perService = new Map(stored.map((s) => [s.name, { service: s.name, missing: [], missingRequired: [], invalid: [], unmanaged: [] }]));
39016
+ const definitionCoverage = sortedDefinitions.map((d) => {
39017
+ const missing = [];
39018
+ const invalid = [];
39019
+ const held = [];
39020
+ for (const s of stored) {
39021
+ const row = perService.get(s.name);
39022
+ const value = s.props.get(d.name);
39023
+ if (value === undefined) {
39024
+ missing.push(s.name);
39025
+ row.missing.push(d.name);
39026
+ if (d.required)
39027
+ row.missingRequired.push(d.name);
39028
+ continue;
39029
+ }
39030
+ held.push(value);
39031
+ const problem = checkPropertyValue(d, value);
39032
+ if (problem) {
39033
+ invalid.push({ service: s.name, property: d.name, value, problem });
39034
+ row.invalid.push({ property: d.name, value, problem });
39035
+ }
39036
+ }
39037
+ const values = count(held);
39038
+ return {
39039
+ name: d.name,
39040
+ valueType: d.valueType,
39041
+ required: d.required,
39042
+ defaultValue: d.defaultValue ?? '',
39043
+ holders: held.length,
39044
+ missing,
39045
+ invalid,
39046
+ values,
39047
+ variants: valueVariants(values),
39048
+ unusedOptions: d.valueType === 'enum' ? (d.allowedValues ?? []).map((a) => a.value).filter((o) => !(o in values)) : [],
39049
+ };
39050
+ });
39051
+ const unmanagedHolders = new Map();
39052
+ for (const s of stored) {
39053
+ for (const [key, value] of s.props) {
39054
+ if (managed.has(key))
39055
+ continue;
39056
+ const entry = unmanagedHolders.get(key) ?? { services: [], values: [] };
39057
+ entry.services.push(s.name);
39058
+ entry.values.push(value);
39059
+ unmanagedHolders.set(key, entry);
39060
+ perService.get(s.name).unmanaged.push(key);
39061
+ }
39062
+ }
39063
+ const managedNames = sortedDefinitions.map((d) => d.name);
39064
+ const unmanaged = [...unmanagedHolders.entries()]
39065
+ .map(([name, { services: holders, values }]) => {
39066
+ const suggestion = suggestType(values);
39067
+ return {
39068
+ name,
39069
+ holders: holders.length,
39070
+ services: holders,
39071
+ values: count(values),
39072
+ suggestedType: suggestion.type,
39073
+ suggestedOptions: suggestion.options,
39074
+ resembles: resembles(name, managedNames),
39075
+ };
39076
+ })
39077
+ .sort((a, b) => b.holders - a.holders || a.name.localeCompare(b.name));
39078
+ return {
39079
+ totalServices: services.length,
39080
+ definitions: definitionCoverage,
39081
+ services: [...perService.values()],
39082
+ unmanaged,
39083
+ };
39084
+ }
39085
+
39086
+ /**
39087
+ * The service-property grid (#1629): one row per service, one column per property, edited in a
39088
+ * spreadsheet (CSV) or by a script (JSON) and imported back. Each row carries the values it was
39089
+ * exported with (`baseline`), so an import changes only what was edited and refuses a cell
39090
+ * someone else changed since the export. Trailing machine columns start with `_`; a property
39091
+ * name must start with a letter, so they never collide with one.
39092
+ */
39093
+ const PROPERTY_GRID_FORMAT = 'dxdo.service-properties/1';
39094
+ const GRID_SERVICE_COLUMN = 'service';
39095
+ const GRID_MACHINE_COLUMNS = ['_issues', '_id', '_tenant', '_baseline'];
39096
+ const propertiesOf = (s) => {
39097
+ const cp = s.customProperties;
39098
+ if (!cp)
39099
+ return new Map();
39100
+ if (Array.isArray(cp))
39101
+ return new Map(cp.map((p) => [p.name, p.value ?? '']));
39102
+ return new Map(Object.entries(cp).map(([k, v]) => [k, v ?? '']));
39103
+ };
39104
+ /**
39105
+ * The grid for `services`, plus how many unmanaged keys it left out (they are opt-in).
39106
+ */
39107
+ function buildPropertyGrid(definitions, services, opts) {
39108
+ const coverage = propertyCoverage(definitions, services);
39109
+ const byName = (a, b) => a.localeCompare(b);
39110
+ const required = definitions.filter((d) => d.required).map((d) => d.name).sort(byName);
39111
+ const optional = opts.requiredOnly ? [] : definitions.filter((d) => !d.required).map((d) => d.name).sort(byName);
39112
+ const unmanaged = coverage.unmanaged.map((u) => u.name);
39113
+ const columns = [...required, ...optional, ...(opts.unmanaged ? unmanaged : [])];
39114
+ const gaps = new Map(coverage.services.map((s) => [s.service, s]));
39115
+ const rows = services.map((s) => {
39116
+ const props = propertiesOf(s);
39117
+ const baseline = Object.fromEntries(columns.map((c) => [c, props.get(c) ?? '']));
39118
+ const gap = gaps.get(s.name);
39119
+ const issues = [
39120
+ ...(gap?.missingRequired.length ? [`missing required: ${gap.missingRequired.join(', ')}`] : []),
39121
+ ...(gap?.invalid ?? []).map((v) => `${v.property}: ${v.problem}`),
39122
+ ];
39123
+ return { service: s.name, id: s.id ?? '', values: { ...baseline }, issues, baseline };
39124
+ });
39125
+ return {
39126
+ grid: { format: PROPERTY_GRID_FORMAT, tenant: opts.tenant, exportedAt: opts.exportedAt, columns, rows },
39127
+ omittedUnmanaged: opts.unmanaged ? [] : unmanaged,
39128
+ };
39129
+ }
39130
+ const FORMULA_START = /^[=+\-@]/;
39131
+ const NUMERIC = /^-?(\d+(\.\d*)?|\.\d+)([eE][-+]?\d+)?$/;
39132
+ /** Cells a spreadsheet would evaluate as a formula when the file is opened by double-click. */
39133
+ function formulaLikeCells(grid) {
39134
+ return grid.rows.flatMap((r) => grid.columns
39135
+ .map((c) => ({ service: r.service, property: c, value: r.values[c] ?? '' }))
39136
+ .filter((v) => FORMULA_START.test(v.value) && !NUMERIC.test(v.value)));
39137
+ }
39138
+ // ---------------------------------------------------------------------------- CSV / JSON codec
39139
+ const BOM = '\uFEFF';
39140
+ const encodeBaseline = (b) => Buffer.from(JSON.stringify(b), 'utf8').toString('base64url');
39141
+ const decodeBaseline = (s) => {
39142
+ const parsed = JSON.parse(Buffer.from(s, 'base64url').toString('utf8'));
39143
+ if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
39144
+ throw new Error('not an object');
39145
+ return Object.fromEntries(Object.entries(parsed).map(([k, v]) => [k, String(v ?? '')]));
39146
+ };
39147
+ const csvCell = (v) => (/[",\r\n;\t]|^\s|\s$/.test(v) ? `"${v.replace(/"/g, '""')}"` : v);
39148
+ /**
39149
+ * The grid as a header row plus one row of strings per service: the shape every tabular format
39150
+ * (CSV, XLSX) writes and {@link parseGridRows} reads back.
39151
+ */
39152
+ function gridToRows(grid) {
39153
+ const header = [GRID_SERVICE_COLUMN, ...grid.columns, ...GRID_MACHINE_COLUMNS];
39154
+ return [
39155
+ header,
39156
+ ...grid.rows.map((r) => [
39157
+ r.service,
39158
+ ...grid.columns.map((c) => r.values[c] ?? ''),
39159
+ r.issues.join('; '),
39160
+ r.id,
39161
+ grid.tenant ?? '',
39162
+ encodeBaseline(r.baseline),
39163
+ ]),
39164
+ ];
39165
+ }
39166
+ /** RFC 4180 CSV with a UTF-8 BOM (so Excel reads non-ASCII names) and CRLF line ends. */
39167
+ function gridToCsv(grid) {
39168
+ return BOM + gridToRows(grid).map((l) => l.map(csvCell).join(',')).join('\r\n') + '\r\n';
39169
+ }
39170
+ /** The delimiter a spreadsheet saved with: ',' normally, ';' in comma-decimal locales, tab for TSV. */
39171
+ function detectDelimiter(text) {
39172
+ const firstLine = text.slice(0, text.search(/\r?\n|$/));
39173
+ const counts = [',', ';', '\t'].map((d) => [d, firstLine.split(d).length - 1]);
39174
+ return [...counts].sort((a, b) => b[1] - a[1])[0]?.[0] ?? ',';
39175
+ }
39176
+ /** Parses RFC 4180 CSV (quoted fields, doubled quotes, newlines inside quotes). */
39177
+ function parseCsv(input) {
39178
+ const text = input.startsWith(BOM) ? input.slice(1) : input;
39179
+ const delimiter = detectDelimiter(text);
39180
+ const rows = [];
39181
+ let row = [];
39182
+ let field = '';
39183
+ let quoted = false;
39184
+ for (let i = 0; i < text.length; i++) {
39185
+ const ch = text[i];
39186
+ if (quoted) {
39187
+ if (ch === '"' && text[i + 1] === '"') {
39188
+ field += '"';
39189
+ i++;
39190
+ }
39191
+ else if (ch === '"') {
39192
+ quoted = false;
39193
+ }
39194
+ else {
39195
+ field += ch;
39196
+ }
39197
+ }
39198
+ else if (ch === '"' && field === '') {
39199
+ quoted = true;
39200
+ }
39201
+ else if (ch === delimiter) {
39202
+ row.push(field);
39203
+ field = '';
39204
+ }
39205
+ else if (ch === '\n' || ch === '\r') {
39206
+ if (ch === '\r' && text[i + 1] === '\n')
39207
+ i++;
39208
+ row.push(field);
39209
+ rows.push(row);
39210
+ row = [];
39211
+ field = '';
39212
+ }
39213
+ else {
39214
+ field += ch;
39215
+ }
39216
+ }
39217
+ if (field !== '' || row.length > 0) {
39218
+ row.push(field);
39219
+ rows.push(row);
39220
+ }
39221
+ return rows.filter((r) => r.some((c) => c.trim() !== ''));
39222
+ }
39223
+ function gridToJson(grid) {
39224
+ return JSON.stringify(grid, null, 2) + '\n';
39225
+ }
39226
+ /** Reads an exported grid back (CSV or JSON, decided by content). */
39227
+ function parsePropertyGrid(text) {
39228
+ const trimmed = (text.startsWith(BOM) ? text.slice(1) : text).trimStart();
39229
+ return trimmed.startsWith('{') ? parseJsonGrid(trimmed) : parseCsvGrid(text);
39230
+ }
39231
+ function parseJsonGrid(text) {
39232
+ const raw = JSON.parse(text);
39233
+ if (raw.format !== PROPERTY_GRID_FORMAT) {
39234
+ return { tenant: null, columns: [], rows: [], problems: [`not a ${PROPERTY_GRID_FORMAT} file (format: ${String(raw.format)})`] };
39235
+ }
39236
+ const problems = [];
39237
+ const rows = (raw.rows ?? []).map((r, i) => {
39238
+ if (!r.baseline || typeof r.baseline !== 'object')
39239
+ problems.push(`row ${i + 1} (${r.service}): no baseline; only exported rows can be imported`);
39240
+ return { ...r, values: r.values ?? {}, issues: r.issues ?? [], baseline: r.baseline ?? {}, id: r.id ?? '' };
39241
+ });
39242
+ return { tenant: raw.tenant ?? null, columns: raw.columns ?? [], rows, problems };
39243
+ }
39244
+ function parseCsvGrid(text) {
39245
+ return parseGridRows(parseCsv(text));
39246
+ }
39247
+ /** Reads a grid back from its rows of strings (header first), whatever file they came from. */
39248
+ function parseGridRows(input) {
39249
+ const [header, ...body] = input.filter((r) => r.some((c) => c.trim() !== ''));
39250
+ if (!header)
39251
+ return { tenant: null, columns: [], rows: [], problems: ['the file is empty'] };
39252
+ const index = (name) => header.findIndex((h) => h.trim().toLowerCase() === name);
39253
+ const serviceAt = index(GRID_SERVICE_COLUMN);
39254
+ const baselineAt = index('_baseline');
39255
+ const problems = [];
39256
+ if (serviceAt < 0)
39257
+ problems.push(`no '${GRID_SERVICE_COLUMN}' column`);
39258
+ if (baselineAt < 0)
39259
+ problems.push("no '_baseline' column; import a file made by service export-properties");
39260
+ if (problems.length)
39261
+ return { tenant: null, columns: [], rows: [], problems };
39262
+ const idAt = index('_id');
39263
+ const tenantAt = index('_tenant');
39264
+ const columnAt = header
39265
+ .map((h, i) => ({ name: h.trim(), i }))
39266
+ .filter((c) => c.i !== serviceAt && c.name !== '' && !c.name.startsWith('_'));
39267
+ const tenants = new Set();
39268
+ const rows = body.map((cells, n) => {
39269
+ const service = (cells[serviceAt] ?? '').trim();
39270
+ let baseline = {};
39271
+ try {
39272
+ baseline = decodeBaseline((cells[baselineAt] ?? '').trim());
39273
+ }
39274
+ catch {
39275
+ problems.push(`row ${n + 2} (${service}): unreadable _baseline; only exported rows can be imported`);
39276
+ }
39277
+ if (tenantAt >= 0 && cells[tenantAt])
39278
+ tenants.add(cells[tenantAt].trim());
39279
+ return {
39280
+ service,
39281
+ id: idAt >= 0 ? (cells[idAt] ?? '').trim() : '',
39282
+ values: Object.fromEntries(columnAt.map((c) => [c.name, cells[c.i] ?? ''])),
39283
+ issues: [],
39284
+ baseline,
39285
+ };
39286
+ });
39287
+ if (tenants.size > 1)
39288
+ problems.push(`rows from more than one tenant: ${[...tenants].join(', ')}`);
39289
+ return { tenant: [...tenants][0] ?? null, columns: columnAt.map((c) => c.name), rows, problems };
39290
+ }
39291
+ // ---------------------------------------------------------------------------- import planning
39292
+ /**
39293
+ * Why `edited` looks like a spreadsheet's automatic conversion of `original` rather than an edit,
39294
+ * or undefined. Such a cell is reported and left alone.
39295
+ */
39296
+ function spreadsheetMangling(original, edited) {
39297
+ if (original === '' || original === edited)
39298
+ return undefined;
39299
+ if (/^0\d+$/.test(original) && edited === original.replace(/^0+(?=\d)/, ''))
39300
+ return 'leading zeros stripped';
39301
+ if (/^\d{12,}$/.test(original) && /^\d(\.\d+)?e\+?\d+$/i.test(edited))
39302
+ return 'long number shown in scientific notation';
39303
+ if (NUMERIC.test(original) && NUMERIC.test(edited) && Number(original) === Number(edited))
39304
+ return 'number reformatted';
39305
+ if (/^\d{4}-\d{2}-\d{2}/.test(original) && !/^\d{4}-\d{2}-\d{2}/.test(edited) && !Number.isNaN(Date.parse(edited))) {
39306
+ return 'date reformatted';
39307
+ }
39308
+ if (/^\d{1,2}[-/]\d{1,2}$/.test(original) && /^\d{1,2}-[A-Za-z]{3}$|^[A-Za-z]{3}-\d{1,2}$|^\d{4}-\d{2}-\d{2}/.test(edited)) {
39309
+ return 'converted to a date';
39310
+ }
39311
+ if (/^(true|false)$/i.test(original) && original.toLowerCase() === edited.toLowerCase())
39312
+ return 'converted to a boolean';
39313
+ return undefined;
39314
+ }
39315
+ /** Services whose row has a cell that differs from its baseline: the only ones an import reads again. */
39316
+ function editedServices(grid) {
39317
+ return grid.rows
39318
+ .filter((r) => grid.columns.some((c) => ((r.values[c] ?? '').trim() === '' ? '' : r.values[c]) !== (r.baseline[c] ?? '')))
39319
+ .map((r) => r.service);
39320
+ }
39321
+ /**
39322
+ * `services` with each one's properties taken from a hierarchy read where it has them, plus the
39323
+ * services the read found that the list lacks. The services list can lag a save by up to a minute
39324
+ * (and miss a just-created service); the hierarchy read is what a save is built from, so existence
39325
+ * and conflicts are judged against it.
39326
+ */
39327
+ function withGraphProperties(services, graph) {
39328
+ const listed = new Set(services.map((s) => s.name));
39329
+ const overlaid = services.map((s) => {
39330
+ const vertex = graph.vertices[s.name];
39331
+ return vertex ? { ...s, customProperties: vertex.attributes.customProperties ?? [] } : s;
39332
+ });
39333
+ const unlisted = Object.entries(graph.vertices)
39334
+ .filter(([name]) => !listed.has(name))
39335
+ .map(([name, vertex]) => ({ name, customProperties: vertex.attributes.customProperties ?? [] }));
39336
+ return [...overlaid, ...unlisted];
39337
+ }
39338
+ /**
39339
+ * The changes an edited grid asks for, checked against the tenant as it is now:
39340
+ * - a cell equal to its baseline is untouched;
39341
+ * - a cell that looks like a spreadsheet conversion of its baseline is a warning, not a write;
39342
+ * - an edited cell whose current value differs from its baseline is a conflict (blocker);
39343
+ * - a cleared cell removes the key only with `force`;
39344
+ * - a managed value its type or options reject, a column that is not a managed property or a key
39345
+ * any service holds, an unknown or renamed service, a duplicate row and a tenant mismatch block.
39346
+ */
39347
+ function planPropertyGridImport(grid, ctx) {
39348
+ const blockers = [...grid.problems];
39349
+ const warnings = [];
39350
+ const edits = [];
39351
+ if (grid.tenant && ctx.tenant && grid.tenant !== ctx.tenant) {
39352
+ blockers.push(`the file was exported from tenant ${grid.tenant}, not ${ctx.tenant}`);
39353
+ }
39354
+ const definitions = new Map(ctx.definitions.map((d) => [d.name, d]));
39355
+ const current = new Map(ctx.services.map((s) => [s.name, s]));
39356
+ const byId = new Map(ctx.services.filter((s) => s.id).map((s) => [s.id, s.name]));
39357
+ const heldKeys = new Set(ctx.services.flatMap((s) => [...propertiesOf(s).keys()]));
39358
+ const unknown = grid.columns.filter((c) => !definitions.has(c) && !heldKeys.has(c));
39359
+ for (const c of unknown)
39360
+ blockers.push(`column '${c}' is not a managed property or a key any service holds (a header typo?)`);
39361
+ const known = grid.columns.filter((c) => !unknown.includes(c));
39362
+ const seen = new Set();
39363
+ let unchanged = 0;
39364
+ for (const row of grid.rows) {
39365
+ if (seen.has(row.service)) {
39366
+ blockers.push(`service '${row.service}' appears in more than one row`);
39367
+ continue;
39368
+ }
39369
+ seen.add(row.service);
39370
+ const cellOf = (column) => ((row.values[column] ?? '').trim() === '' ? '' : row.values[column]);
39371
+ if (known.every((column) => cellOf(column) === (row.baseline[column] ?? ''))) {
39372
+ unchanged++;
39373
+ continue;
39374
+ }
39375
+ const now = current.get(row.service);
39376
+ if (!now) {
39377
+ const renamed = row.id ? byId.get(row.id) : undefined;
39378
+ blockers.push(renamed
39379
+ ? `service '${row.service}' was renamed to '${renamed}' since the export; re-export`
39380
+ : `service '${row.service}' no longer exists`);
39381
+ continue;
39382
+ }
39383
+ const props = propertiesOf(now);
39384
+ let rowEdited = false;
39385
+ for (const column of known) {
39386
+ const cell = cellOf(column);
39387
+ const base = row.baseline[column] ?? '';
39388
+ if (cell === base)
39389
+ continue;
39390
+ const mangled = spreadsheetMangling(base, cell);
39391
+ if (mangled) {
39392
+ warnings.push(`${row.service}.${column}: '${base}' → '${cell}' looks like ${mangled} by the spreadsheet; left unchanged`);
39393
+ continue;
39394
+ }
39395
+ rowEdited = true;
39396
+ const value = props.get(column) ?? '';
39397
+ if (value !== base) {
39398
+ blockers.push(`${row.service}.${column} changed since the export ('${base}' → now '${value}'); re-export and edit again`);
39399
+ continue;
39400
+ }
39401
+ if (cell === '') {
39402
+ if (ctx.force)
39403
+ edits.push({ service: row.service, property: column, before: base, after: '', kind: 'remove' });
39404
+ else
39405
+ blockers.push(`${row.service}.${column}: clearing the cell removes '${base}'; pass force=true to remove it`);
39406
+ continue;
39407
+ }
39408
+ const definition = definitions.get(column);
39409
+ const problem = definition ? checkPropertyValue(definition, cell) : undefined;
39410
+ if (problem) {
39411
+ blockers.push(`${row.service}.${column}: ${problem}`);
39412
+ continue;
39413
+ }
39414
+ edits.push({ service: row.service, property: column, before: base, after: cell, kind: 'set' });
39415
+ }
39416
+ if (!rowEdited)
39417
+ unchanged++;
39418
+ }
39419
+ const changes = edits.map((e) => e.kind === 'set'
39420
+ ? { op: 'setProperty', service: e.service, name: e.property, value: e.after }
39421
+ : { op: 'removeProperty', service: e.service, name: e.property });
39422
+ return { changes, edits, blockers, warnings, unchanged };
39423
+ }
39424
+
39425
+ /**
39426
+ * Routing exposure of custom properties (#1628): which notification policies and alarm queues
39427
+ * filter on `service_custom_properties.<key>`, and what a service without the key does to them.
39428
+ *
39429
+ * Measured on THE_LABORATORY (#1628): a policy links a queue through `alarmViews: [<queue id>]`,
39430
+ * and the UI also copies the queue's atoms into the policy's own `filterExpressionV1`. An alarm
39431
+ * whose services lack the key never matches `equals` / `contains`, and always matches
39432
+ * `not_equals` / `not_contains` (even for a key nobody holds). That was measured through the
39433
+ * alarm query a queue uses; the notification engine is assumed to evaluate the same way.
39434
+ */
39435
+ const SERVICE_PROPERTY_FIELD_PREFIX = 'service_custom_properties.';
39436
+ const MISSING_KEY_EFFECT = {
39437
+ equals: 'never matches',
39438
+ contains: 'never matches',
39439
+ not_equals: 'always matches',
39440
+ not_contains: 'always matches',
39441
+ };
39442
+ /** What an alarm from a service without the key does to an atom with `condition`. */
39443
+ const missingKeyEffect = (condition) => MISSING_KEY_EFFECT[condition] ?? 'not measured';
39444
+ function propertyAtoms(expression) {
39445
+ if (!expression || typeof expression !== 'object')
39446
+ return [];
39447
+ return policyFilterAtoms(expression)
39448
+ .filter((a) => typeof a.field === 'string' && a.field.startsWith(SERVICE_PROPERTY_FIELD_PREFIX))
39449
+ .map((a) => ({ property: a.field.slice(SERVICE_PROPERTY_FIELD_PREFIX.length), condition: a.condition, value: String(a.value) }));
39450
+ }
39451
+ const atomKey = (a) => `${a.property}\u0000${a.condition}\u0000${a.value}`;
39452
+ const POSITIVE = new Set(['equals']);
39453
+ /**
39454
+ * Every atom on a service custom property in `policies` (their own filters plus the queues they
39455
+ * link) and in `queues`, with the services in `coverage` that lack the key and what that does.
39456
+ */
39457
+ function propertyRoutingExposure(policies, queues, coverage) {
39458
+ const allServices = coverage.services.map((s) => s.service);
39459
+ const keyFacts = (property) => {
39460
+ const managed = coverage.definitions.find((d) => d.name === property);
39461
+ if (managed)
39462
+ return { managed: true, missing: managed.missing, heldValues: managed.values, holders: managed.holders };
39463
+ const unmanaged = coverage.unmanaged.find((u) => u.name === property);
39464
+ const holders = new Set(unmanaged?.services ?? []);
39465
+ return {
39466
+ managed: false,
39467
+ missing: allServices.filter((s) => !holders.has(s)),
39468
+ heldValues: unmanaged?.values ?? {},
39469
+ holders: holders.size,
39470
+ };
39471
+ };
39472
+ const queueById = new Map(queues.map((q) => [q.id, q]));
39473
+ const usedBy = new Map();
39474
+ for (const p of policies) {
39475
+ for (const id of p.alarmViews ?? [])
39476
+ usedBy.set(String(id), [...(usedBy.get(String(id)) ?? []), p.name]);
39477
+ }
39478
+ const rows = (kind, item, sourced) => [...sourced.values()].map(({ atom, source }) => {
39479
+ const facts = keyFacts(atom.property);
39480
+ const notes = [];
39481
+ if (facts.holders === 0 && !facts.managed)
39482
+ notes.push('no service holds this key and it has no definition (a typo?)');
39483
+ if (POSITIVE.has(atom.condition) && facts.holders > 0 && !(atom.value in facts.heldValues)) {
39484
+ notes.push(`no service holds '${atom.value}'`);
39485
+ }
39486
+ return {
39487
+ kind,
39488
+ name: item.name,
39489
+ alarmCategory: item.alarmCategory ?? '',
39490
+ active: item.active ?? null,
39491
+ source,
39492
+ property: atom.property,
39493
+ condition: atom.condition,
39494
+ value: atom.value,
39495
+ managed: facts.managed,
39496
+ totalServices: coverage.totalServices,
39497
+ holders: facts.holders,
39498
+ missing: facts.missing,
39499
+ missingEffect: missingKeyEffect(atom.condition),
39500
+ heldValues: facts.heldValues,
39501
+ notes,
39502
+ usedBy: item.usedBy,
39503
+ channels: item.channels,
39504
+ };
39505
+ });
39506
+ const collect = (into, atoms, source) => {
39507
+ for (const atom of atoms) {
39508
+ const entry = into.get(atomKey(atom)) ?? { atom, source: [] };
39509
+ if (!entry.source.includes(source))
39510
+ entry.source.push(source);
39511
+ into.set(atomKey(atom), entry);
39512
+ }
39513
+ };
39514
+ const policyRows = policies.flatMap((p) => {
39515
+ const sourced = new Map();
39516
+ collect(sourced, propertyAtoms(p.filterExpressionV1), 'own filter');
39517
+ for (const id of p.alarmViews ?? []) {
39518
+ const q = queueById.get(String(id));
39519
+ if (q)
39520
+ collect(sourced, propertyAtoms(q.filterExpressions), `queue ${q.filterName}`);
39521
+ }
39522
+ return rows('policy', { name: p.name, alarmCategory: p.alarmCategory, active: p.active, channels: p.channelNames ?? [], usedBy: [] }, sourced);
39523
+ });
39524
+ const queueRows = queues.flatMap((q) => {
39525
+ const sourced = new Map();
39526
+ collect(sourced, propertyAtoms(q.filterExpressions), 'own filter');
39527
+ return rows('queue', { name: q.filterName, alarmCategory: q.alarmCategory, channels: [], usedBy: usedBy.get(q.id) ?? [] }, sourced);
39528
+ });
39529
+ return [...policyRows, ...queueRows];
39530
+ }
39531
+
38798
39532
  var CreateServices;
38799
39533
  (function (CreateServices) {
38800
39534
  /** The service kinds the platform recognises, in wire casing (`servicerepo/filters` catalog). */
@@ -40628,6 +41362,391 @@ class SimpleHTTPError extends Error {
40628
41362
  }
40629
41363
  }
40630
41364
 
41365
+ /**
41366
+ * Synthetics access policies (2026-11 release): `synthetics/permission-service/api/v1/policies`.
41367
+ * A policy grants READ or WRITE on the monitors of one monitor group (a RESOURCE rule) — or on all
41368
+ * monitors (no RESOURCE rule) — to user groups or users named in a SUBJECT rule. Measured on
41369
+ * THE_LABORATORY (#1599, #1584): names are unique (a duplicate create is a 400); `PUT …/{id}`
41370
+ * updates a policy in place (the UI instead deletes and recreates, leaving a window with no
41371
+ * access); `DELETE …/{id}` is a 204; subject names are NEVER checked against existing groups, and
41372
+ * a renamed or deleted group stays named here.
41373
+ */
41374
+ const SYNTHETIC_ACCESS_ACTIONS = ['READ', 'WRITE'];
41375
+ const SYNTHETIC_ACCESS_SUBJECTS = ['userGroup', 'user'];
41376
+ const SyntheticAccessRuleSchema = z.looseObject({
41377
+ attributeType: z.string().describe('SUBJECT (who) or RESOURCE (which monitors)'),
41378
+ attributeName: z.string().describe('SUBJECT: userGroup | user; RESOURCE: group'),
41379
+ operator: z.string().describe('SUBJECT: IN; RESOURCE: EQUALS'),
41380
+ attributeValue: z.union([z.string(), z.array(z.string())]).describe('SUBJECT: names; RESOURCE: the monitor group'),
41381
+ });
41382
+ const SyntheticAccessPolicySchema = z.looseObject({
41383
+ id: z.number().describe('Path key for update and delete'),
41384
+ tenantId: z.string().optional(),
41385
+ name: z.string().describe('Unique; the UI names them <usergroups|users>_<ACTION>_<monitor group|all>'),
41386
+ description: z.string().nullable().optional(),
41387
+ resourceType: z.string().describe("'monitor'"),
41388
+ action: z.string().describe('READ | WRITE'),
41389
+ effect: z.string().describe("'ALLOW'"),
41390
+ active: z.boolean(),
41391
+ rules: z.array(SyntheticAccessRuleSchema),
41392
+ });
41393
+ const SyntheticAccessPolicyListSchema = z.array(SyntheticAccessPolicySchema);
41394
+ const SyntheticAccessPolicyWriteSchema = z.looseObject({
41395
+ name: z.string().min(1),
41396
+ description: z.string(),
41397
+ resourceType: z.literal('monitor'),
41398
+ action: z.enum(SYNTHETIC_ACCESS_ACTIONS),
41399
+ effect: z.literal('ALLOW'),
41400
+ active: z.boolean(),
41401
+ rules: z.array(SyntheticAccessRuleSchema).min(1),
41402
+ });
41403
+ const asList = (v) => (Array.isArray(v) ? v : [v]);
41404
+ /** Reads what a policy grants, or undefined when it is not the shape the UI writes. */
41405
+ function policyGrant(policy) {
41406
+ const subject = policy.rules.find((r) => r.attributeType === 'SUBJECT');
41407
+ const resource = policy.rules.find((r) => r.attributeType === 'RESOURCE' && r.attributeName === 'group');
41408
+ const kind = subject?.attributeName;
41409
+ if (!subject || !kind || !SYNTHETIC_ACCESS_SUBJECTS.includes(kind))
41410
+ return undefined;
41411
+ if (!SYNTHETIC_ACCESS_ACTIONS.includes(policy.action))
41412
+ return undefined;
41413
+ return {
41414
+ subject: kind,
41415
+ names: asList(subject.attributeValue),
41416
+ action: policy.action,
41417
+ monitorGroup: resource ? String(asList(resource.attributeValue)[0] ?? '') : null,
41418
+ };
41419
+ }
41420
+ /** The UI's policy name: `usergroups_READ_payments`, `users_WRITE_all`. */
41421
+ function accessPolicyName(subject, action, monitorGroup) {
41422
+ return `${subject === 'userGroup' ? 'usergroups' : 'users'}_${action}_${monitorGroup ?? 'all'}`;
41423
+ }
41424
+ /** The body for a policy granting `action` on `monitorGroup` (null = all monitors) to `names`. */
41425
+ function accessPolicyBody(grant, name = accessPolicyName(grant.subject, grant.action, grant.monitorGroup)) {
41426
+ return {
41427
+ name,
41428
+ description: '',
41429
+ resourceType: 'monitor',
41430
+ action: grant.action,
41431
+ effect: 'ALLOW',
41432
+ active: true,
41433
+ rules: [
41434
+ { attributeType: 'SUBJECT', attributeName: grant.subject, operator: 'IN', attributeValue: grant.names },
41435
+ ...(grant.monitorGroup === null
41436
+ ? []
41437
+ : [{ attributeType: 'RESOURCE', attributeName: 'group', operator: 'EQUALS', attributeValue: grant.monitorGroup }]),
41438
+ ],
41439
+ };
41440
+ }
41441
+ /**
41442
+ * The one write that grants (`add`) or revokes (`remove`) `name`'s `action` on `monitorGroup`:
41443
+ * the policy for that (subject kind, action, monitor group) is updated in place, created when there
41444
+ * is none, and deleted when its last subject is revoked. Policies are matched by what they grant,
41445
+ * not by name.
41446
+ */
41447
+ function planAccessChange(policies, change) {
41448
+ const match = policies.find((p) => {
41449
+ const g = policyGrant(p);
41450
+ return g && g.subject === change.subject && g.action === change.action && g.monitorGroup === change.monitorGroup;
41451
+ });
41452
+ const current = match ? policyGrant(match) : undefined;
41453
+ const scope = change.monitorGroup === null ? 'all monitors' : `monitor group '${change.monitorGroup}'`;
41454
+ if (change.op === 'add') {
41455
+ if (current?.names.includes(change.name))
41456
+ return { kind: 'none', reason: `'${change.name}' already has ${change.action} on ${scope}` };
41457
+ if (!match || !current) {
41458
+ return { kind: 'create', body: accessPolicyBody({ subject: change.subject, names: [change.name], action: change.action, monitorGroup: change.monitorGroup }) };
41459
+ }
41460
+ return {
41461
+ kind: 'update',
41462
+ id: match.id,
41463
+ before: current.names,
41464
+ body: accessPolicyBody({ ...current, names: [...current.names, change.name] }, match.name),
41465
+ };
41466
+ }
41467
+ if (!match || !current || !current.names.includes(change.name)) {
41468
+ return { kind: 'none', reason: `'${change.name}' has no ${change.action} grant on ${scope}` };
41469
+ }
41470
+ const remaining = current.names.filter((n) => n !== change.name);
41471
+ if (remaining.length === 0)
41472
+ return { kind: 'delete', id: match.id, before: current.names };
41473
+ return { kind: 'update', id: match.id, before: current.names, body: accessPolicyBody({ ...current, names: remaining }, match.name) };
41474
+ }
41475
+
41476
+ /**
41477
+ * Roles (2026-11 release). Measured on THE_LABORATORY (#1584, #1597):
41478
+ * - `GET ess/roles/v1?cohort=<GUID>` is the catalog: built-in PU, SA, TA, UZ and custom `VIEW####`
41479
+ * roles, each with a level, a permission tree (`taskMap`) and a description.
41480
+ * - The same roles are DataStore views with `attributes.owner: 'DP'` (`views/view/{id}`). WHO HOLDS
41481
+ * a role is the view's `access.users` and `access.groups` (groups by NAME). A grant or revoke is a
41482
+ * full `PUT` of the view carrying `lastModificationTimestamp`; a stale timestamp is refused (409,
41483
+ * "View … was updated meanwhile") and nothing changes.
41484
+ * - Built-in roles' features cannot be edited; their holders can.
41485
+ * These views do not fit the generic DataStore view schema (`views` is a list of feature filters and
41486
+ * grants carry `permissions`), so they have their own.
41487
+ */
41488
+ const BUILT_IN_ROLE_IDS = ['PU', 'SA', 'TA', 'UZ'];
41489
+ /** The tenant admin role: revoking its last holder would lock admins out. */
41490
+ const TENANT_ADMIN_ROLE_ID = 'TA';
41491
+ const RoleCatalogEntrySchema = z.looseObject({
41492
+ name: z.string().describe('Role id: PU, SA, TA, UZ, or VIEW#### for a custom role'),
41493
+ displayName: z.string().optional().describe('e.g. Tenant Admin'),
41494
+ level: z.number().optional().describe('Privilege level: TA 800, SA 750, PU 500, UZ 100, custom 0'),
41495
+ roleDescription: z.string().optional(),
41496
+ customRoles: z.unknown().optional(),
41497
+ privileges: z.unknown().optional(),
41498
+ taskMap: z.unknown().optional().describe('The permission tree'),
41499
+ });
41500
+ const RoleCatalogSchema = z.array(RoleCatalogEntrySchema);
41501
+ /** A group or user holding a role. `permissions` is what the UI writes: READ, WRITE, DELETE. */
41502
+ const RoleGrantSchema = z.looseObject({
41503
+ name: z.string().describe('Group name or user login'),
41504
+ permissions: z.array(z.string()).optional().describe('The UI grants READ, WRITE and DELETE'),
41505
+ });
41506
+ const RoleViewSchema = z.looseObject({
41507
+ viewId: z.string().describe('Role id (PU, SA, TA, UZ, VIEW####)'),
41508
+ access: z
41509
+ .looseObject({
41510
+ groups: z.array(RoleGrantSchema).optional().describe('Groups holding the role, by name'),
41511
+ users: z.array(RoleGrantSchema).optional().describe('Users holding the role directly'),
41512
+ })
41513
+ .describe('Who holds the role'),
41514
+ lastModificationTimestamp: z.number().describe('Concurrency token; send it back on PUT'),
41515
+ views: z.array(z.unknown()).optional().describe('Feature filters (the permission tree)'),
41516
+ attributes: z
41517
+ .looseObject({ owner: z.string().optional(), label: z.string().optional(), description: z.string().optional() })
41518
+ .optional(),
41519
+ inactive: z.boolean().optional(),
41520
+ });
41521
+ /** The permissions the UI writes when a role is granted. */
41522
+ const ROLE_GRANT_PERMISSIONS = ['READ', 'WRITE', 'DELETE'];
41523
+ const grants = (view, kind) => view.access[kind] ?? [];
41524
+ /** The view with `name` added to its group or user holders (unchanged when already there). */
41525
+ function withRoleGrant(view, kind, name) {
41526
+ if (grants(view, kind).some((g) => g.name === name))
41527
+ return view;
41528
+ return { ...view, access: { ...view.access, [kind]: [...grants(view, kind), { name, permissions: [...ROLE_GRANT_PERMISSIONS] }] } };
41529
+ }
41530
+ /** The view with `name` removed from its group or user holders. */
41531
+ function withoutRoleGrant(view, kind, name) {
41532
+ return { ...view, access: { ...view.access, [kind]: grants(view, kind).filter((g) => g.name !== name) } };
41533
+ }
41534
+ /** Group and user names holding the role. */
41535
+ function roleHolders(view) {
41536
+ return { groups: grants(view, 'groups').map((g) => g.name), users: grants(view, 'users').map((g) => g.name) };
41537
+ }
41538
+
41539
+ function allGroupReferences(roleViews, policies) {
41540
+ const fromRoles = roleViews.flatMap((v) => roleHolders(v).groups.map((group) => ({
41541
+ group,
41542
+ kind: 'role',
41543
+ id: v.viewId,
41544
+ label: v.attributes?.label ?? v.viewId,
41545
+ grants: `role ${v.attributes?.label ?? v.viewId}`,
41546
+ })));
41547
+ const fromPolicies = policies.flatMap((p) => {
41548
+ const grant = policyGrant(p);
41549
+ if (!grant || grant.subject !== 'userGroup')
41550
+ return [];
41551
+ return grant.names.map((group) => ({
41552
+ group,
41553
+ kind: 'synthetics-access',
41554
+ id: String(p.id),
41555
+ label: p.name,
41556
+ grants: `${grant.action} on ${grant.monitorGroup === null ? 'all monitors' : `monitor group '${grant.monitorGroup}'`}`,
41557
+ }));
41558
+ });
41559
+ return [...fromRoles, ...fromPolicies];
41560
+ }
41561
+ /** The roles and access policies that name `group`. */
41562
+ function groupReferences(group, roleViews, policies) {
41563
+ return allGroupReferences(roleViews, policies).filter((r) => r.group === group);
41564
+ }
41565
+ /** References to group names no existing group has: access that silently grants nobody. */
41566
+ function danglingGroupReferences(existingGroups, roleViews, policies) {
41567
+ const existing = new Set(existingGroups);
41568
+ return allGroupReferences(roleViews, policies).filter((r) => !existing.has(r.group));
41569
+ }
41570
+
41571
+ /**
41572
+ * User groups (2026-11 release): `ess/usergroups/v1`. Measured on THE_LABORATORY (#1584, #1597):
41573
+ * names are unique (a duplicate create is a 400, code 1251341); `PUT …/{id}` replaces the whole
41574
+ * member list and can rename; `DELETE …/{id}` is a 204. Roles and synthetics access policies name a
41575
+ * group by its NAME, so a rename or a delete leaves those references dangling — the platform does
41576
+ * not follow or check them.
41577
+ */
41578
+ const UserGroupUserInfoSchema = z.looseObject({
41579
+ userId: z.string().describe('Login id'),
41580
+ firstName: z.string().optional(),
41581
+ lastName: z.string().optional(),
41582
+ statusEnum: z.string().optional().describe('e.g. ACTIVE'),
41583
+ userType: z.string().optional(),
41584
+ userRefID: z.union([z.number(), z.string()]).optional().describe('Id used by the ess/users endpoints (a number on the lab)'),
41585
+ dateCreated: z.string().optional(),
41586
+ dateModified: z.string().optional(),
41587
+ });
41588
+ /** One group as listed (`GET …/list`, no members) or read (`GET …/{id}`, members on request). */
41589
+ const UserGroupSchema = z.looseObject({
41590
+ groupId: z.number().describe('Numeric id; the path key for read, update and delete'),
41591
+ groupName: z.string().describe('Unique; what roles and access policies reference'),
41592
+ description: z.string().optional(),
41593
+ created: z.string().optional().describe('ISO time'),
41594
+ lastUpdated: z.string().optional().describe('ISO time'),
41595
+ lastUpdatedBy: z.string().optional(),
41596
+ tenantId: z.string().optional(),
41597
+ userIds: z.array(z.string()).optional().describe('Members; only with include_userids=true'),
41598
+ userInfos: z.array(UserGroupUserInfoSchema).optional().describe('Member details; only with include_userinfos=true'),
41599
+ });
41600
+ const UserGroupListSchema = z.array(UserGroupSchema);
41601
+ /** Create body (`POST ess/usergroups/v1`); update (`PUT …/{id}`) adds `groupId` and replaces members. */
41602
+ const UserGroupWriteSchema = z.object({
41603
+ groupName: z.string().trim().min(1).describe('Unique group name'),
41604
+ description: z.string().describe('"" for none'),
41605
+ userIds: z.array(z.string().min(1)).describe('The complete member list (login ids)'),
41606
+ });
41607
+
41608
+ /**
41609
+ * A service's Availability KPI, set from one of its SLIs (#1564; UI HAR, 2026-11-15).
41610
+ *
41611
+ * The KPI is one entry of `type: 'availability'` in the service's `attributes.metrics`, saved with the rest of the
41612
+ * service (`oi/v2/sa/save?replace=true`); clearing it removes the entry. Set from an SLI, the entry points at the SLI's
41613
+ * SLO Threshold metric (`<service uuid>:<SLI name> Threshold` on `OI|SA|SERVICES|ALL`), which emits 1 for an interval
41614
+ * that meets the objective (`threshold_emit_value`) and 0 otherwise; the UI saves threshold 0.5, so the service counts
41615
+ * as available while the objective is met. Only an Availability SLI with an SLO qualifies, and only once its Threshold
41616
+ * metric is published: a few minutes after the SLI or its SLO is created or changed. Renaming the SLI renames the
41617
+ * metric, and a KPI set before the rename keeps pointing at the old one.
41618
+ */
41619
+ var AvailabilityKpi;
41620
+ (function (AvailabilityKpi) {
41621
+ AvailabilityKpi.SOURCE = 'OI|SA|SERVICES|ALL';
41622
+ AvailabilityKpi.THRESHOLD = 0.5;
41623
+ /** How far back a Threshold metric must have reported to count as published (the UI asks for 24 h). */
41624
+ AvailabilityKpi.PUBLISHED_WINDOW_MS = 86_400_000;
41625
+ AvailabilityKpi.NOT_PUBLISHED = 'its SLO Threshold metric is not published yet: it appears a few minutes after the SLI or its SLO is created or changed; list again shortly';
41626
+ /** The service's KPI entry, if it has one. */
41627
+ function currentEntry(metrics) {
41628
+ return (metrics ?? []).find((m) => m.type === 'availability');
41629
+ }
41630
+ AvailabilityKpi.currentEntry = currentEntry;
41631
+ function isAvailability(sli) {
41632
+ return (sli.sli_type ?? '').toLowerCase() === 'availability';
41633
+ }
41634
+ /** The metric names to look up: every SLI's SLO Threshold metric, and the current KPI's metric. */
41635
+ function metricNames(slis, current) {
41636
+ const names = slis.flatMap((s) => (s.metricsConfig?.slo_threshold?.attributeName ? [s.metricsConfig.slo_threshold.attributeName] : []));
41637
+ if (current)
41638
+ names.push(current.attributeName);
41639
+ return [...new Set(names)];
41640
+ }
41641
+ AvailabilityKpi.metricNames = metricNames;
41642
+ /** Each SLI, whether it can be the KPI now, and why not. */
41643
+ function candidates(slis, published, current) {
41644
+ return slis.map((s) => {
41645
+ const thresholdMetric = s.metricsConfig?.slo_threshold?.attributeName;
41646
+ const found = thresholdMetric ? published.get(thresholdMetric) : undefined;
41647
+ const reason = !isAvailability(s)
41648
+ ? `an SLI of type ${s.sli_type || 'unknown'}: the KPI takes an Availability SLI`
41649
+ : !s.hasSLO || !thresholdMetric
41650
+ ? 'it has no SLO: add one (sli add-slo), then wait a few minutes for its Threshold metric'
41651
+ : !found
41652
+ ? AvailabilityKpi.NOT_PUBLISHED
41653
+ : undefined;
41654
+ return {
41655
+ sli: s.name,
41656
+ sliGroupId: s.id,
41657
+ sliType: s.sli_type,
41658
+ hasSLO: s.hasSLO,
41659
+ ...(s.hasSLO ? { targetPercent: s.target_percent } : {}),
41660
+ ...(thresholdMetric ? { thresholdMetric } : {}),
41661
+ ...(found ? { metricId: found.id, ...(found.firstSeen ? { firstSeen: found.firstSeen } : {}) } : {}),
41662
+ eligible: reason === undefined,
41663
+ ...(reason ? { reason } : {}),
41664
+ current: current !== undefined && thresholdMetric === current.attributeName,
41665
+ };
41666
+ });
41667
+ }
41668
+ AvailabilityKpi.candidates = candidates;
41669
+ /** The current KPI, what it comes from, and whether its metric still reports. */
41670
+ function describeCurrent(entry, slis, published) {
41671
+ if (!entry)
41672
+ return undefined;
41673
+ const sli = slis.find((s) => s.metricsConfig?.slo_threshold?.attributeName === entry.attributeName);
41674
+ const isPublished = published.has(entry.attributeName);
41675
+ const note = !sli
41676
+ ? `not one of this service's SLIs${entry.configSource && entry.configSource !== 'metric' ? ` (configSource ${entry.configSource})` : ''}: it may come from a renamed or deleted SLI, or another source`
41677
+ : !isPublished
41678
+ ? 'its metric has not reported in the last 24 hours, so the service has no availability'
41679
+ : undefined;
41680
+ return {
41681
+ attributeName: entry.attributeName,
41682
+ metricId: entry.id,
41683
+ ...(entry.configSource ? { configSource: entry.configSource } : {}),
41684
+ ...(entry.threshold !== undefined ? { threshold: entry.threshold } : {}),
41685
+ ...(sli ? { sli: sli.name } : {}),
41686
+ published: isPublished,
41687
+ ...(note ? { note } : {}),
41688
+ };
41689
+ }
41690
+ AvailabilityKpi.describeCurrent = describeCurrent;
41691
+ /**
41692
+ * Finds an SLI by exact name, then by name ignoring case. Never by id: the only id the SLI list carries is the SLI
41693
+ * group's, shared by every SLI in the group (#1570).
41694
+ */
41695
+ function findCandidate(list, sli) {
41696
+ return list.find((c) => c.sli === sli) ?? list.find((c) => c.sli.toLowerCase() === sli.toLowerCase());
41697
+ }
41698
+ AvailabilityKpi.findCandidate = findCandidate;
41699
+ /** Why `sli` names none of the service's SLIs, and what it could name instead. */
41700
+ function notFound(list, sli, serviceName) {
41701
+ const group = list.filter((c) => c.sliGroupId === sli);
41702
+ if (group.length > 0) {
41703
+ return `'${sli}' is an SLI group id, not an SLI: pass the SLI's name; that group's SLIs: ${group.map((c) => `'${c.sli}'`).join(', ')}`;
41704
+ }
41705
+ const known = list.map((c) => `'${c.sli}'`).join(', ');
41706
+ return `no SLI '${sli}' on service '${serviceName}'${known ? `; its SLIs: ${known}` : ': it has no SLIs'}`;
41707
+ }
41708
+ AvailabilityKpi.notFound = notFound;
41709
+ /** The KPI entry for an eligible candidate, as the UI saves it. */
41710
+ function entryFor(candidate) {
41711
+ if (!candidate.eligible || !candidate.metricId || !candidate.thresholdMetric) {
41712
+ throw new Error(`SLI '${candidate.sli}' cannot be the availability KPI: ${candidate.reason ?? 'no published Threshold metric'}`);
41713
+ }
41714
+ return {
41715
+ type: 'availability',
41716
+ configSource: 'metric',
41717
+ threshold: AvailabilityKpi.THRESHOLD,
41718
+ id: candidate.metricId,
41719
+ sourceName: AvailabilityKpi.SOURCE,
41720
+ attributeName: candidate.thresholdMetric,
41721
+ };
41722
+ }
41723
+ AvailabilityKpi.entryFor = entryFor;
41724
+ function label(entry, sli) {
41725
+ if (!entry)
41726
+ return 'none';
41727
+ return sli ? `SLI '${sli}' (${entry.attributeName})` : entry.attributeName;
41728
+ }
41729
+ /**
41730
+ * Sets (`entry`) or clears (`null`) the KPI on `serviceName` in a store body, replacing any existing KPI entry.
41731
+ *
41732
+ * @returns change lines; empty when nothing changes.
41733
+ * @throws Error if the service is not in the body.
41734
+ */
41735
+ function apply(body, serviceName, entry, names = {}) {
41736
+ const target = body.vertices.find((v) => v.attributes.name === serviceName);
41737
+ if (!target)
41738
+ throw new Error(`No service with name '${serviceName}' found`);
41739
+ const metrics = target.attributes.metrics ?? [];
41740
+ const before = currentEntry(metrics);
41741
+ if ((before?.attributeName ?? null) === (entry?.attributeName ?? null) && (before?.id ?? null) === (entry?.id ?? null)) {
41742
+ return [];
41743
+ }
41744
+ target.attributes.metrics = [...metrics.filter((m) => m.type !== 'availability'), ...(entry ? [entry] : [])];
41745
+ return [`availability KPI: ${label(before, names.before)} -> ${label(entry ?? undefined, names.after)}`];
41746
+ }
41747
+ AvailabilityKpi.apply = apply;
41748
+ })(AvailabilityKpi || (AvailabilityKpi = {}));
41749
+
40631
41750
  /** @internal */
40632
41751
  const sampleServiceDetailRequestBody = {
40633
41752
  timeFrom: 1772843076673,
@@ -42974,6 +44093,451 @@ function toClusteringPolicyPreviewBody(body) {
42974
44093
  };
42975
44094
  }
42976
44095
 
44096
+ const OPERATION_NAME = /^[A-Za-z_]\w*$/;
44097
+ function classifyArgument(raw) {
44098
+ const trimmed = raw.trim();
44099
+ const quote = trimmed[0];
44100
+ if ((quote === "'" || quote === '"') && trimmed.length >= 2 && trimmed.endsWith(quote)) {
44101
+ return { kind: 'quoted', raw, value: trimmed.slice(1, -1) };
44102
+ }
44103
+ if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
44104
+ const inner = trimmed.slice(1, -1).trim();
44105
+ return { kind: 'list', raw, items: inner === '' ? [] : inner.split(',').map((item) => item.trim()) };
44106
+ }
44107
+ return { kind: 'bare', raw, value: raw };
44108
+ }
44109
+ /**
44110
+ * Splits a template into literal text and `{operation(args)}` calls. Quotes and
44111
+ * `[…]` lists may contain commas, parentheses and braces. Parsing is purely
44112
+ * syntactic; {@link namingTemplateProblems} checks calls against the catalog.
44113
+ */
44114
+ function parseNamingTemplate(template) {
44115
+ const parts = [];
44116
+ const errors = [];
44117
+ let text = '';
44118
+ let index = 0;
44119
+ const flushText = () => {
44120
+ if (text) {
44121
+ parts.push({ kind: 'text', text });
44122
+ text = '';
44123
+ }
44124
+ };
44125
+ while (index < template.length) {
44126
+ const char = template[index];
44127
+ if (char === '}') {
44128
+ errors.push(`unmatched '}' at position ${index}`);
44129
+ return { parts, errors };
44130
+ }
44131
+ if (char !== '{') {
44132
+ text += char;
44133
+ index++;
44134
+ continue;
44135
+ }
44136
+ const start = index;
44137
+ const open = template.indexOf('(', start);
44138
+ const close = template.indexOf('}', start);
44139
+ if (open === -1 || (close !== -1 && close < open)) {
44140
+ errors.push(`'{' at position ${start} is not followed by operation(args) — expected e.g. {split(host,'.',0)}`);
44141
+ return { parts, errors };
44142
+ }
44143
+ const operation = template.slice(start + 1, open).trim();
44144
+ if (!OPERATION_NAME.test(operation)) {
44145
+ errors.push(`'${template.slice(start + 1, open)}' at position ${start + 1} is not an operation name`);
44146
+ return { parts, errors };
44147
+ }
44148
+ const args = [];
44149
+ let current = '';
44150
+ let quote;
44151
+ let depth = 0;
44152
+ let cursor = open + 1;
44153
+ let closedParen = false;
44154
+ for (; cursor < template.length; cursor++) {
44155
+ const c = template[cursor];
44156
+ if (quote) {
44157
+ current += c;
44158
+ if (c === quote)
44159
+ quote = undefined;
44160
+ continue;
44161
+ }
44162
+ if (c === "'" || c === '"') {
44163
+ quote = c;
44164
+ current += c;
44165
+ }
44166
+ else if (c === '[') {
44167
+ depth++;
44168
+ current += c;
44169
+ }
44170
+ else if (c === ']') {
44171
+ depth--;
44172
+ current += c;
44173
+ }
44174
+ else if (c === ',' && depth === 0) {
44175
+ args.push(current);
44176
+ current = '';
44177
+ }
44178
+ else if (c === ')' && depth === 0) {
44179
+ closedParen = true;
44180
+ break;
44181
+ }
44182
+ else {
44183
+ current += c;
44184
+ }
44185
+ }
44186
+ if (quote) {
44187
+ errors.push(`unterminated ${quote} quote in {${operation}(…)} starting at position ${start}`);
44188
+ return { parts, errors };
44189
+ }
44190
+ if (!closedParen) {
44191
+ errors.push(`{${operation}( at position ${start} has no closing ')'`);
44192
+ return { parts, errors };
44193
+ }
44194
+ if (current.trim() !== '' || args.length > 0) {
44195
+ args.push(current);
44196
+ }
44197
+ let after = cursor + 1;
44198
+ while (template[after] === ' ')
44199
+ after++;
44200
+ if (template[after] !== '}') {
44201
+ errors.push(`{${operation}(…) at position ${start} must close with '}' right after ')'`);
44202
+ return { parts, errors };
44203
+ }
44204
+ flushText();
44205
+ parts.push({ kind: 'call', raw: template.slice(start, after + 1), operation, args: args.map(classifyArgument) });
44206
+ index = after + 1;
44207
+ }
44208
+ flushText();
44209
+ return { parts, errors };
44210
+ }
44211
+ const NON_NEGATIVE_INTEGER = /^\d+$/;
44212
+ /** The catalog's parameters for an operation, in positional order. */
44213
+ function orderedParameters(operation) {
44214
+ return [...(operation.parameters ?? [])].sort((a, b) => a.paramNumber - b.paramNumber);
44215
+ }
44216
+ /**
44217
+ * A usable example call built from the catalog's parameter defaults, e.g.
44218
+ * `{split(field,'|',0)}` or `{mostimpacted(field[,3])}` (optional arguments in
44219
+ * brackets).
44220
+ */
44221
+ function namingOperationSignature(operation) {
44222
+ const args = orderedParameters(operation).map((parameter, position) => {
44223
+ const fallback = parameter.defaultValue ?? '';
44224
+ let shown;
44225
+ if (position === 0 && (operation.supportedFields ?? []).length > 0) {
44226
+ shown = 'field';
44227
+ }
44228
+ else if (parameter.type === 'Integer' || fallback.trim().startsWith('[')) {
44229
+ shown = fallback || (parameter.type === 'Integer' ? '0' : '[0]');
44230
+ }
44231
+ else {
44232
+ shown = `'${fallback}'`;
44233
+ }
44234
+ return { shown, optional: !parameter.isMandatory };
44235
+ });
44236
+ let rendered = '';
44237
+ args.forEach((arg, position) => {
44238
+ const separator = position === 0 ? '' : ',';
44239
+ rendered += arg.optional ? `[${separator}${arg.shown}]` : `${separator}${arg.shown}`;
44240
+ });
44241
+ return `{${operation.opName}(${rendered})}`;
44242
+ }
44243
+ /**
44244
+ * Problems that would make the platform reject a template (400) or render a
44245
+ * call as `N/A` for every situation: syntax errors, operations the tenant does
44246
+ * not define, unsupported or space-padded fields, wrong argument counts or
44247
+ * types, and inverted `slice` ranges. With an empty catalog only syntax is
44248
+ * checked. Returns human-readable lines, empty when the template is usable.
44249
+ */
44250
+ function namingTemplateProblems(template, operations) {
44251
+ if (!template) {
44252
+ return [];
44253
+ }
44254
+ const parsed = parseNamingTemplate(template);
44255
+ const problems = parsed.errors.map((error) => `naming template: ${error}`);
44256
+ if (operations.length === 0) {
44257
+ return problems;
44258
+ }
44259
+ const byName = new Map(operations.map((operation) => [operation.opName.toLowerCase(), operation]));
44260
+ for (const part of parsed.parts) {
44261
+ if (part.kind !== 'call')
44262
+ continue;
44263
+ const call = part.raw;
44264
+ const operation = byName.get(part.operation.toLowerCase());
44265
+ if (!operation) {
44266
+ problems.push(`naming template ${call}: this tenant has no '${part.operation}' operation — expected one of ` +
44267
+ operations.map((candidate) => candidate.opName).join(', '));
44268
+ continue;
44269
+ }
44270
+ const declared = operation.parameters !== undefined;
44271
+ const parameters = declared
44272
+ ? orderedParameters(operation)
44273
+ : part.args.map((_, position) => ({ paramNumber: position + 1, isMandatory: true, type: 'String', defaultValue: '' }));
44274
+ const mandatory = parameters.filter((parameter) => parameter.isMandatory).length;
44275
+ if (declared && (part.args.length < mandatory || part.args.length > parameters.length)) {
44276
+ const expected = mandatory === parameters.length ? `${mandatory}` : `${mandatory}-${parameters.length}`;
44277
+ problems.push(`naming template ${call}: ${operation.opName} takes ${expected} argument(s), got ${part.args.length}`);
44278
+ continue;
44279
+ }
44280
+ const supported = (operation.supportedFields ?? []).map((field) => field.field);
44281
+ part.args.forEach((arg, position) => {
44282
+ const parameter = parameters[position];
44283
+ if (!parameter)
44284
+ return;
44285
+ const label = `${operation.opName} argument ${position + 1}`;
44286
+ if (position === 0 && supported.length > 0) {
44287
+ if (arg.kind !== 'bare') {
44288
+ problems.push(`naming template ${call}: ${label} is the alarm field — write it bare, e.g. ${supported[0]}`);
44289
+ }
44290
+ else if (arg.raw !== arg.raw.trim()) {
44291
+ problems.push(`naming template ${call}: field '${arg.raw}' has surrounding spaces — the platform reads them as part of ` +
44292
+ `the field name and renders N/A; write ${arg.raw.trim()}`);
44293
+ }
44294
+ else if (!supported.includes(arg.value)) {
44295
+ problems.push(`naming template ${call}: ${operation.opName} supports ${supported.join(', ')} — not '${arg.value}'`);
44296
+ }
44297
+ return;
44298
+ }
44299
+ if (!declared) {
44300
+ return;
44301
+ }
44302
+ if (parameter.type === 'Integer') {
44303
+ if (arg.kind !== 'bare' || !NON_NEGATIVE_INTEGER.test(arg.value.trim())) {
44304
+ problems.push(`naming template ${call}: ${label} must be a non-negative integer, got ${arg.raw.trim()}`);
44305
+ }
44306
+ return;
44307
+ }
44308
+ if ((parameter.defaultValue ?? '').trim().startsWith('[')) {
44309
+ if (arg.kind !== 'list' || arg.items.length === 0 || arg.items.some((item) => !NON_NEGATIVE_INTEGER.test(item))) {
44310
+ problems.push(`naming template ${call}: ${label} must be a list of segment indices such as [0,2], got ${arg.raw.trim()}`);
44311
+ }
44312
+ return;
44313
+ }
44314
+ if (arg.kind !== 'quoted') {
44315
+ problems.push(`naming template ${call}: ${label} must be a quoted string such as '|', got ${arg.raw.trim()}`);
44316
+ }
44317
+ else if (arg.value === '') {
44318
+ problems.push(`naming template ${call}: ${label} is an empty string — the platform rejects an empty delimiter`);
44319
+ }
44320
+ });
44321
+ if (operation.opName.toLowerCase() === 'slice' && part.args.length >= 4) {
44322
+ const [from, to] = [part.args[2], part.args[3]].map((arg) => Number(arg?.raw.trim()));
44323
+ if (Number.isInteger(from) && Number.isInteger(to) && from > to) {
44324
+ problems.push(`naming template ${call}: slice start ${from} is after its end ${to} — the range is inclusive a..b`);
44325
+ }
44326
+ }
44327
+ }
44328
+ return problems;
44329
+ }
44330
+
44331
+ /**
44332
+ * The server's own explanation of a situation (2026-11, the situation Details tab):
44333
+ * `POST oi/v2/api/clusteralarms/explain/{clusterId}` with body `{}`. Shapes from the owner's
44334
+ * capture and from reading open, closed, force-closed and 24-alarm situations (#1614): all 16
44335
+ * sections were present every time; every one is optional and loose anyway.
44336
+ * It answers "why is this situation like this" directly: why it opened (policy, seed alarm,
44337
+ * criteria), why it has this name, which alarms it holds, when and why it stabilises or closes,
44338
+ * and a plain-language narration.
44339
+ *
44340
+ * Measured: an unknown id is a 200 with no `identity`, the headline "Situation #… not found." and
44341
+ * a data-quality note — see {@link situationExplanationFound}. `alarmBreakdown.alarms` lists at
44342
+ * most 20 alarms; the counts cover all of them.
44343
+ */
44344
+ const str$1 = (d) => z.string().optional().describe(d);
44345
+ const num = (d) => z.number().optional().describe(d);
44346
+ const bool$1 = (d) => z.boolean().optional().describe(d);
44347
+ const strs = (d) => z.array(z.string()).optional().describe(d);
44348
+ const counts = (d) => z.record(z.string(), z.number()).optional().describe(d);
44349
+ const SituationExplainIdentitySchema = z.looseObject({
44350
+ clusterId: str$1('Situation id'),
44351
+ clusterName: str$1('Situation name'),
44352
+ status: str$1('Status code'),
44353
+ statusTranslated: str$1('Status, as shown'),
44354
+ severity: str$1('Severity code'),
44355
+ severityTranslated: str$1('Severity, as shown'),
44356
+ stableState: str$1('Stability state'),
44357
+ clusteringType: str$1('Situation type, e.g. Custom'),
44358
+ hosts: strs('Hosts of its alarms'),
44359
+ mostImpactedHost: str$1('The host with the most alarms'),
44360
+ startTime: str$1('When the situation started'),
44361
+ firstAlarmStartTime: str$1('When its first alarm started'),
44362
+ timestamp: str$1('Last change'),
44363
+ policyId: str$1('Situation policy id'),
44364
+ policyName: str$1('Situation policy name'),
44365
+ noiseFlag: bool$1('Marked as noise'),
44366
+ stable: bool$1('Stable'),
44367
+ closed: bool$1('Closed'),
44368
+ clusterPrevName: str$1('The name before a rename'),
44369
+ stableTime: str$1('When it became stable'),
44370
+ endTime: str$1('When it closed (epoch ms, as a string)'),
44371
+ });
44372
+ const SituationExplainNameSchema = z.looseObject({
44373
+ strategy: str$1('How the name was formed'),
44374
+ currentName: str$1('The current name'),
44375
+ pattern: str$1('The naming pattern'),
44376
+ representativeAlarmId: str$1('The alarm the name was taken from'),
44377
+ renamed: bool$1('Whether it was renamed since it opened'),
44378
+ previousName: str$1('The name before the rename'),
44379
+ plainDescription: str$1('Why it has this name, in words'),
44380
+ });
44381
+ const SituationExplainCreationSchema = z.looseObject({
44382
+ policyId: str$1('Policy that opened it'),
44383
+ policyName: str$1('Policy that opened it'),
44384
+ clusteringType: str$1('Situation type'),
44385
+ triggeredAt: str$1('When it opened'),
44386
+ seedAlarmId: str$1('The alarm that opened it'),
44387
+ seedAlarmSummary: str$1('That alarm’s message'),
44388
+ seedAlarmSource: str$1('That alarm’s source'),
44389
+ carryOverMinutes: num('Carry-over window, minutes'),
44390
+ groupingCriteriaApplied: strs('Grouping criteria the policy applied'),
44391
+ filterCriteriaApplied: strs('Filter criteria the policy applied'),
44392
+ plainDescription: str$1('Why it opened, in words'),
44393
+ });
44394
+ const SituationExplainMembershipSchema = z.looseObject({
44395
+ totalAlarms: num('Alarms in it'),
44396
+ subClustersCount: num('Sub-clusters'),
44397
+ distinctHostsCount: num('Distinct hosts'),
44398
+ hosts: strs('Hosts'),
44399
+ impactedServices: strs('Impacted services'),
44400
+ subClusters: z
44401
+ .array(z.looseObject({
44402
+ message: str$1('Sub-cluster message'),
44403
+ severity: str$1('Severity'),
44404
+ alarmCount: num('Alarms'),
44405
+ rootCause: bool$1('Marked root cause'),
44406
+ rcaScore: num('Root-cause score'),
44407
+ }))
44408
+ .optional()
44409
+ .describe('Sub-clusters (alarms grouped by message)'),
44410
+ matchCriteria: strs('What its alarms have in common'),
44411
+ correlationRationale: str$1('Why these alarms belong together, in words'),
44412
+ });
44413
+ const SituationExplainAlarmSchema = z.looseObject({
44414
+ alarmId: str$1('Alarm id'),
44415
+ message: str$1('Message'),
44416
+ severity: str$1('Severity'),
44417
+ status: str$1('Status'),
44418
+ host: str$1('Host'),
44419
+ metric: str$1('Metric'),
44420
+ metricValue: str$1('Metric value'),
44421
+ threshold: str$1('Threshold'),
44422
+ product: str$1('Product'),
44423
+ startTime: str$1('Start'),
44424
+ timestamp: str$1('Last change'),
44425
+ });
44426
+ const SituationExplainBreakdownSchema = z.looseObject({
44427
+ totalAlarms: num('Alarms ever in it'),
44428
+ currentMembers: num('Alarms in it now'),
44429
+ activeAlarms: num('Active alarms'),
44430
+ clearedAlarms: num('Cleared alarms'),
44431
+ disassociatedAlarms: num('Alarms that left it'),
44432
+ aggregated: bool$1('Whether alarms are aggregated'),
44433
+ bySeverity: counts('Alarms per severity'),
44434
+ byStatus: counts('Alarms per status'),
44435
+ byHost: counts('Alarms per host'),
44436
+ byProduct: counts('Alarms per product'),
44437
+ byMessage: counts('Alarms per message'),
44438
+ alarms: z.array(SituationExplainAlarmSchema).optional().describe('Its alarms'),
44439
+ });
44440
+ const SituationExplainTimelineEntrySchema = z.looseObject({
44441
+ timestamp: str$1('When'),
44442
+ propName: str$1('What changed (lifecycle property)'),
44443
+ oldValue: z.unknown().optional(),
44444
+ newValue: z.unknown().optional(),
44445
+ updatedBy: str$1('Who changed it'),
44446
+ userType: str$1('User or system'),
44447
+ lifeEvent: bool$1('A lifecycle milestone'),
44448
+ what: str$1('What happened, in words'),
44449
+ why: str$1('Why, in words'),
44450
+ trigger: z.looseObject({ evidenceType: str$1('Evidence type'), actor: str$1('Actor') }).optional(),
44451
+ });
44452
+ const SituationExplainStabilizationSchema = z.looseObject({
44453
+ reasonCode: str$1('Why it is (not yet) stable'),
44454
+ confidence: str$1('Confidence of the projection'),
44455
+ stableWindowMinutes: num('Stable window, minutes'),
44456
+ toleranceMinutes: num('Tolerance, minutes'),
44457
+ policyWindows: z
44458
+ .looseObject({
44459
+ stableWindow: num('Stable window'),
44460
+ extensionWindow: num('Extension window'),
44461
+ maxStableWindow: num('Maximum stable window'),
44462
+ autoExtendEnabled: bool$1('Auto-extend on'),
44463
+ mode: str$1('Mode'),
44464
+ source: str$1('Where the windows come from'),
44465
+ policyLastUpdated: str$1('Policy last updated'),
44466
+ })
44467
+ .optional()
44468
+ .describe('The policy’s stabilisation windows'),
44469
+ expectedWindowMinutes: z.looseObject({ earliest: num('Earliest'), latest: num('Latest') }).optional(),
44470
+ projection: z
44471
+ .looseObject({
44472
+ currentAgeMinutes: num('Age now, minutes'),
44473
+ earliestStableAt: str$1('Earliest time it can become stable'),
44474
+ latestStableAt: str$1('Latest time'),
44475
+ plainDescription: str$1('The projection, in words'),
44476
+ })
44477
+ .optional(),
44478
+ evidence: strs('Evidence'),
44479
+ plainDescription: str$1('Stabilisation, in words'),
44480
+ forceStable: bool$1('Forced stable'),
44481
+ stable: bool$1('Stable'),
44482
+ stableTime: str$1('When it became stable'),
44483
+ ageAtStabilizationMinutes: num('Age when it became stable, minutes'),
44484
+ arithmeticProof: str$1('The window arithmetic behind the stable time, in words'),
44485
+ });
44486
+ const SituationExplainClosureSchema = z.looseObject({
44487
+ closureType: str$1('How it closed or will close'),
44488
+ reasonCode: str$1('Why it is (not) closed'),
44489
+ confidence: str$1('Confidence'),
44490
+ openAlarmsRemaining: num('Open alarms left'),
44491
+ plainDescription: str$1('Closure, in words'),
44492
+ closed: bool$1('Closed'),
44493
+ forceClosed: bool$1('Force-closed'),
44494
+ closedAt: str$1('When it closed'),
44495
+ closureProcess: str$1('The process that closed it, e.g. StableClusterClosureJob'),
44496
+ closedBy: str$1('Who closed it'),
44497
+ daysSinceLastUpdateAtClosure: num('Days since its last update when it closed'),
44498
+ evidence: strs('Evidence'),
44499
+ });
44500
+ const SituationExplainNarrationSchema = z.looseObject({
44501
+ headline: str$1('One-line summary'),
44502
+ currentState: str$1('Where it stands now'),
44503
+ story: strs('The story so far, as sentences'),
44504
+ storyItems: z
44505
+ .array(z.looseObject({
44506
+ at: str$1('When'),
44507
+ what: str$1('What happened'),
44508
+ why: str$1('Why'),
44509
+ trigger: z.looseObject({ type: str$1('Trigger type'), actor: str$1('Actor'), evidence: strs('Evidence') }).optional(),
44510
+ }))
44511
+ .optional()
44512
+ .describe('The story as events'),
44513
+ insights: strs('Observations'),
44514
+ whatNext: str$1('What to expect or do next'),
44515
+ });
44516
+ const SituationExplanationSchema = z.looseObject({
44517
+ clusterId: str$1('Situation id'),
44518
+ tenantId: str$1('Tenant'),
44519
+ generatedAt: str$1('When the explanation was generated'),
44520
+ identity: SituationExplainIdentitySchema.optional(),
44521
+ nameFormation: SituationExplainNameSchema.optional(),
44522
+ creationReason: SituationExplainCreationSchema.optional(),
44523
+ membershipExplanation: SituationExplainMembershipSchema.optional(),
44524
+ alarmBreakdown: SituationExplainBreakdownSchema.optional(),
44525
+ lifecycleTimeline: z.array(SituationExplainTimelineEntrySchema).optional(),
44526
+ stabilizationExplanation: SituationExplainStabilizationSchema.optional(),
44527
+ closureExplanation: SituationExplainClosureSchema.optional(),
44528
+ rootCause: z.looseObject({ applicable: bool$1('Root cause applies'), plainDescription: str$1('Root cause, in words') }).optional(),
44529
+ incident: z.looseObject({ hasTicket: bool$1('A ticket exists'), plainDescription: str$1('Incident, in words') }).optional(),
44530
+ workNotes: z.array(z.unknown()).optional().describe('Work notes'),
44531
+ narration: SituationExplainNarrationSchema.optional(),
44532
+ dataQualityNotes: z.array(z.unknown()).optional().describe('Gaps in the data behind the explanation'),
44533
+ });
44534
+ /** The most alarms `alarmBreakdown.alarms` lists (measured: 20 of a 24-alarm situation). */
44535
+ const SITUATION_EXPLAIN_ALARM_LIST_MAX = 20;
44536
+ /** False for the server's not-found answer (a 200 with no `identity`). */
44537
+ function situationExplanationFound(explanation) {
44538
+ return explanation.identity !== undefined;
44539
+ }
44540
+
42977
44541
  /**
42978
44542
  * One row of an SLI group's match criteria. SLI groups select the metrics they
42979
44543
  * watch by a list of these filters (e.g. "Source contains bd605" AND
@@ -49356,9 +50920,11 @@ class AlarmService {
49356
50920
  * (it used to ask for 20 and stop, dropping the oldest events, "Alarm
49357
50921
  * Opened" first). `totalCount` is returned as the server reported it; if a
49358
50922
  * page comes back empty early, the result holds fewer events and a warning
49359
- * is logged.
50923
+ * is logged. With `propertySearch`, the server keeps only events whose
50924
+ * `propName` contains the text (case-insensitive) and `totalCount` counts
50925
+ * those.
49360
50926
  */
49361
- async getAlarmLifeCycle(alarmId) {
50927
+ async getAlarmLifeCycle(alarmId, options = {}) {
49362
50928
  return readLifecyclePages((pageNumber, pageSize) => this.dxSaaSService.oiPost('oi/v2/api/alarms/lifecycle/_search', {
49363
50929
  alarmId,
49364
50930
  pageSize: String(pageSize),
@@ -49367,9 +50933,11 @@ class AlarmService {
49367
50933
  excludeFields: [
49368
50934
  'isolation_view_link',
49369
50935
  'metric_view_link',
50936
+ 'metric_group_link',
49370
50937
  'alert_definition_link',
49371
50938
  'occurrence',
49372
50939
  ],
50940
+ ...(options.propertySearch ? { searchText: options.propertySearch } : {}),
49373
50941
  }), `alarm ${alarmId}`, this.simpleLog);
49374
50942
  }
49375
50943
  /**
@@ -53396,8 +54964,8 @@ class ChannelService {
53396
54964
  }
53397
54965
 
53398
54966
  var NullSimpleLog$7 = Logging.NullSimpleLog;
53399
- const BASE$1 = 'oi/v2/api/clusteralarms';
53400
- const POLICY = `${BASE$1}/clusteringpolicy`;
54967
+ const BASE$4 = 'oi/v2/api/clusteralarms';
54968
+ const POLICY = `${BASE$4}/clusteringpolicy`;
53401
54969
  /**
53402
54970
  * Custom situation policies (the product's "custom situation definitions";
53403
54971
  * the API's clustering policies). Backs the `situation *-custom-situation-policy`
@@ -53530,7 +55098,7 @@ class ClusteringPolicyService {
53530
55098
  * `[min, max]`.
53531
55099
  */
53532
55100
  async listPolicyFields() {
53533
- const raw = await this.dxSaasService.oiGet(`${BASE$1}/policyfields`);
55101
+ const raw = await this.dxSaasService.oiGet(`${BASE$4}/policyfields`);
53534
55102
  const result = PolicyFieldsResponseSchema.safeParse(raw);
53535
55103
  if (!result.success) {
53536
55104
  this.log.warn('PolicyFieldsResponse validation warning:', result.error.message);
@@ -53544,7 +55112,7 @@ class ClusteringPolicyService {
53544
55112
  * `GET oi/v2/api/clusteralarms/tenantConfigAttributes`
53545
55113
  */
53546
55114
  async getTenantConfigAttributes() {
53547
- const raw = await this.dxSaasService.oiGet(`${BASE$1}/tenantConfigAttributes`);
55115
+ const raw = await this.dxSaasService.oiGet(`${BASE$4}/tenantConfigAttributes`);
53548
55116
  const result = TenantConfigAttributesResponseSchema.safeParse(raw);
53549
55117
  if (!result.success) {
53550
55118
  this.log.warn('TenantConfigAttributesResponse validation warning:', result.error.message);
@@ -53612,7 +55180,7 @@ class ClusteringPolicyService {
53612
55180
  async setTenantConfigAttributes(tenantId, attributes) {
53613
55181
  const body = { tenantId, configAttrList: attributes };
53614
55182
  TenantConfigAttributesWriteBodySchema.parse(body);
53615
- const raw = await this.dxSaasService.oiPut(`${BASE$1}/tenantConfigAttributes`, body);
55183
+ const raw = await this.dxSaasService.oiPut(`${BASE$4}/tenantConfigAttributes`, body);
53616
55184
  const result = TenantConfigAttributesWriteResponseSchema.safeParse(raw);
53617
55185
  if (!result.success) {
53618
55186
  this.log.warn('TenantConfigAttributesWriteResponse validation warning:', result.error.message);
@@ -53621,6 +55189,95 @@ class ClusteringPolicyService {
53621
55189
  }
53622
55190
  }
53623
55191
 
55192
+ const BASE$3 = 'oi/v2/sa/customproperties';
55193
+ /**
55194
+ * Managed custom service property definitions (`oi/v2/sa/customproperties`, 2026-11).
55195
+ * Semantics measured on THE_LABORATORY (#1583) are on each method.
55196
+ */
55197
+ class CustomPropertyService {
55198
+ dxSaaSService;
55199
+ log;
55200
+ constructor(dxSaaSService, log = new Logging.NullSimpleLog()) {
55201
+ this.dxSaaSService = dxSaaSService;
55202
+ this.log = log;
55203
+ }
55204
+ /**
55205
+ * Every definition, with `usageCount` and (enum) per-value usage.
55206
+ *
55207
+ * @remarks Response-validated, not thrown.
55208
+ */
55209
+ async listDefinitions() {
55210
+ const raw = await this.dxSaaSService.oiGet(BASE$3);
55211
+ const result = CustomPropertyDefinitionListSchema.safeParse(raw);
55212
+ if (!result.success)
55213
+ this.log.warn('CustomPropertyDefinition list validation warning:', result.error.message);
55214
+ return (raw ?? []);
55215
+ }
55216
+ /** One definition by name, or undefined. */
55217
+ async findDefinition(name) {
55218
+ return (await this.listDefinitions()).find((d) => d.name === name);
55219
+ }
55220
+ /**
55221
+ * Which services hold the key, and their values. An unknown name answers `count: 0`, not 404.
55222
+ *
55223
+ * @remarks Response-validated, not thrown.
55224
+ */
55225
+ async getUsage(name) {
55226
+ const raw = await this.dxSaaSService.oiGet(`${BASE$3}/${encodeURIComponent(name)}/usage`);
55227
+ const result = CustomPropertyUsageSchema.safeParse(raw);
55228
+ if (!result.success)
55229
+ this.log.warn('CustomPropertyUsage validation warning:', result.error.message);
55230
+ return raw;
55231
+ }
55232
+ /**
55233
+ * Creates a definition. The server answers 409 for an existing name and 400 for an invalid
55234
+ * name, empty enum options, or a default the type does not allow.
55235
+ *
55236
+ * @throws ZodError when `body` breaks the same rules (checked before sending).
55237
+ */
55238
+ async createDefinition(body) {
55239
+ CustomPropertyWriteSchema.parse(body);
55240
+ const raw = await this.dxSaaSService.oiPost(BASE$3, body);
55241
+ const result = CustomPropertyWriteResponseSchema.safeParse(raw);
55242
+ if (!result.success)
55243
+ this.log.warn('CustomPropertyWriteResponse validation warning:', result.error.message);
55244
+ return raw;
55245
+ }
55246
+ /**
55247
+ * Replaces a definition (full body). The name cannot change (400). The value type and enum
55248
+ * options CAN change while services hold values; the server leaves those values as they are,
55249
+ * so check usage first. 404 when the definition does not exist.
55250
+ *
55251
+ * @throws ZodError when `body` is invalid, or Error when `body.name` differs from `name`.
55252
+ */
55253
+ async updateDefinition(name, body) {
55254
+ CustomPropertyWriteSchema.parse(body);
55255
+ if (body.name !== name) {
55256
+ throw new Error(`a custom property definition cannot be renamed ('${name}' → '${body.name}'); delete and recreate it`);
55257
+ }
55258
+ const raw = await this.dxSaaSService.oiPut(`${BASE$3}/${encodeURIComponent(name)}`, body);
55259
+ const result = CustomPropertyWriteResponseSchema.safeParse(raw);
55260
+ if (!result.success)
55261
+ this.log.warn('CustomPropertyWriteResponse validation warning:', result.error.message);
55262
+ return raw;
55263
+ }
55264
+ /**
55265
+ * Coverage of the managed properties over `services` (pass `ServiceService.getAllServices()`,
55266
+ * or a scoped subset of it; the ungrouped list carries `customProperties` on every service).
55267
+ * Reads the definitions; everything else is the pure `propertyCoverage`.
55268
+ */
55269
+ async coverage(services) {
55270
+ return propertyCoverage(await this.listDefinitions(), services);
55271
+ }
55272
+ /**
55273
+ * Deletes a definition (204). The server deletes it even while services hold the key; those
55274
+ * values stay on the services as unmanaged keys. 404 when it does not exist.
55275
+ */
55276
+ async deleteDefinition(name) {
55277
+ await this.dxSaaSService.oiDelete(`${BASE$3}/${encodeURIComponent(name)}`);
55278
+ }
55279
+ }
55280
+
53624
55281
  var PermissionType = DashboardPermissionsUpdateRequest.PermissionType;
53625
55282
  /**
53626
55283
  * Service for Grafana-style dashboard API: themes, API keys, dashboards,
@@ -53697,6 +55354,18 @@ class DashboardService {
53697
55354
  getDashboard(uid) {
53698
55355
  return this.dxSaaSService.dashboardGet(`api/dashboards/uid/${uid}`);
53699
55356
  }
55357
+ /** Deletes a dashboard by UID. */
55358
+ deleteDashboard(uid) {
55359
+ return this.dxSaaSService.dashboardDelete(`api/dashboards/uid/${uid}`);
55360
+ }
55361
+ /** Deletes a folder by UID, with every dashboard in it. */
55362
+ deleteFolder(folderUid) {
55363
+ return this.dxSaaSService.dashboardDelete(`api/folders/${folderUid}`);
55364
+ }
55365
+ /** Returns the org's datasources (name, uid, plugin type) — what a panel's `{ type, uid }` datasource points at. */
55366
+ getDatasources() {
55367
+ return this.dxSaaSService.dashboardGet('api/datasources');
55368
+ }
53700
55369
  /** Returns all dashboards within a specific folder. */
53701
55370
  getDashboardsInFolder(folderId) {
53702
55371
  return this.dxSaaSService.dashboardGet('api/search', {
@@ -87788,7 +89457,7 @@ async function sendWithRetry(post, batches, options = {}) {
87788
89457
  return result;
87789
89458
  }
87790
89459
 
87791
- const BASE = LogMetric.BASE_PATH;
89460
+ const BASE$2 = LogMetric.BASE_PATH;
87792
89461
  /**
87793
89462
  * Log-based metric definitions (Log Analytics "define metrics from logs"). Callers pass and
87794
89463
  * receive plain Lucene; the service escapes it for the wire and unescapes what it reads. It
@@ -87814,7 +89483,7 @@ class LogMetricService {
87814
89483
  * @throws LogMetricError when the body code is not 200
87815
89484
  */
87816
89485
  async list() {
87817
- const response = await this.call(this.dxSaasService.oiGet(BASE), 'list log metric definitions');
89486
+ const response = await this.call(this.dxSaasService.oiGet(BASE$2), 'list log metric definitions');
87818
89487
  return (Array.isArray(response) ? response : []).map((raw) => LogMetric.fromWire(this.checked(raw)));
87819
89488
  }
87820
89489
  /**
@@ -87823,7 +89492,7 @@ class LogMetricService {
87823
89492
  * @throws LogMetricError when the body code is not 200
87824
89493
  */
87825
89494
  async count() {
87826
- const response = await this.call(this.dxSaasService.oiGet(`${BASE}/count`), 'count log metric definitions');
89495
+ const response = await this.call(this.dxSaasService.oiGet(`${BASE$2}/count`), 'count log metric definitions');
87827
89496
  const result = LogMetric.CountSchema.safeParse(response);
87828
89497
  if (!result.success)
87829
89498
  this.log.warn('LogMetric count validation warning:', result.error.message);
@@ -87836,7 +89505,7 @@ class LogMetricService {
87836
89505
  */
87837
89506
  async get(name) {
87838
89507
  try {
87839
- const response = await this.call(this.dxSaasService.oiGet(`${BASE}/${this.pathName(name)}`, { mode: 'edit' }), `get log metric '${name}'`);
89508
+ const response = await this.call(this.dxSaasService.oiGet(`${BASE$2}/${this.pathName(name)}`, { mode: 'edit' }), `get log metric '${name}'`);
87840
89509
  return LogMetric.fromWire(this.checked(response));
87841
89510
  }
87842
89511
  catch (e) {
@@ -87853,7 +89522,7 @@ class LogMetricService {
87853
89522
  */
87854
89523
  async validateName(name) {
87855
89524
  try {
87856
- await this.call(this.dxSaasService.oiPost(`${BASE}/${this.pathName(name)}/_validate`), `validate name '${name}'`);
89525
+ await this.call(this.dxSaasService.oiPost(`${BASE$2}/${this.pathName(name)}/_validate`), `validate name '${name}'`);
87857
89526
  return 'free';
87858
89527
  }
87859
89528
  catch (e) {
@@ -87867,7 +89536,7 @@ class LogMetricService {
87867
89536
  * accepted on save; the list is reported verbatim.
87868
89537
  */
87869
89538
  async functions() {
87870
- const raw = await this.dxSaasService.oiGet(`${BASE}/functions`);
89539
+ const raw = await this.dxSaasService.oiGet(`${BASE$2}/functions`);
87871
89540
  if (!Array.isArray(raw)) {
87872
89541
  this.log.warn('LogMetric functions validation warning: expected an array');
87873
89542
  return [];
@@ -87889,7 +89558,7 @@ class LogMetricService {
87889
89558
  throw new LogMetric.LogMetricError('invalid', `range must be a whole number of minutes from 1 to ${LogMetric.PREVIEW_MAX_MINUTES}, got ${rangeMinutes}`);
87890
89559
  }
87891
89560
  await this.refuseSilentInputs(parsed);
87892
- const response = await this.call(this.dxSaasService.oiPost(`${BASE}/${this.pathName(parsed.name)}/execute`, LogMetric.toWireBody(parsed, 1), { range: rangeMinutes }), `preview '${parsed.name}'`);
89561
+ const response = await this.call(this.dxSaasService.oiPost(`${BASE$2}/${this.pathName(parsed.name)}/execute`, LogMetric.toWireBody(parsed, 1), { range: rangeMinutes }), `preview '${parsed.name}'`);
87893
89562
  const result = LogMetric.PreviewResponseSchema.safeParse(response);
87894
89563
  if (!result.success)
87895
89564
  this.log.warn('LogMetric preview validation warning:', result.error.message);
@@ -87911,7 +89580,7 @@ class LogMetricService {
87911
89580
  if ((await this.validateName(parsed.name)) === 'taken') {
87912
89581
  throw new LogMetric.LogMetricError('name-taken', `a log metric named '${parsed.name}' already exists`);
87913
89582
  }
87914
- await this.call(this.dxSaasService.oiPost(`${BASE}/${this.pathName(parsed.name)}`, LogMetric.toWireBody(parsed, 1)), `create '${parsed.name}'`);
89583
+ await this.call(this.dxSaasService.oiPost(`${BASE$2}/${this.pathName(parsed.name)}`, LogMetric.toWireBody(parsed, 1)), `create '${parsed.name}'`);
87915
89584
  return this.readBack(parsed.name);
87916
89585
  }
87917
89586
  /**
@@ -87932,7 +89601,7 @@ class LogMetricService {
87932
89601
  }
87933
89602
  const merged = LogMetric.DefinitionInputSchema.parse({ ...LogMetric.toInput(current), ...patch, name });
87934
89603
  await this.refuseSilentInputs(merged);
87935
- await this.call(this.dxSaasService.oiPut(`${BASE}/${this.pathName(name)}`, LogMetric.toWireBody(merged, current.version)), `update '${name}'`);
89604
+ await this.call(this.dxSaasService.oiPut(`${BASE$2}/${this.pathName(name)}`, LogMetric.toWireBody(merged, current.version)), `update '${name}'`);
87936
89605
  return this.readBack(name);
87937
89606
  }
87938
89607
  /**
@@ -87941,7 +89610,7 @@ class LogMetricService {
87941
89610
  * @throws LogMetricError `not-found` when there is no such definition
87942
89611
  */
87943
89612
  async setEnabled(name, enabled) {
87944
- await this.call(this.dxSaasService.oiPut(`${BASE}/${this.pathName(name)}/setProperty`, undefined, { enable: enabled }), `${enabled ? 'enable' : 'disable'} '${name}'`);
89613
+ await this.call(this.dxSaasService.oiPut(`${BASE$2}/${this.pathName(name)}/setProperty`, undefined, { enable: enabled }), `${enabled ? 'enable' : 'disable'} '${name}'`);
87945
89614
  }
87946
89615
  /**
87947
89616
  * Deletes a definition. Series already written stay in the metric store.
@@ -87949,7 +89618,7 @@ class LogMetricService {
87949
89618
  * @throws LogMetricError `not-found` when there is no such definition
87950
89619
  */
87951
89620
  async delete(name) {
87952
- await this.call(this.dxSaasService.oiDelete(`${BASE}/${this.pathName(name)}`), `delete '${name}'`);
89621
+ await this.call(this.dxSaasService.oiDelete(`${BASE$2}/${this.pathName(name)}`), `delete '${name}'`);
87953
89622
  }
87954
89623
  /**
87955
89624
  * The per-minute counts a definition wrote, one entry per series (Total Count and one per
@@ -89701,6 +91370,249 @@ class PlatformManagementModuleService {
89701
91370
  }
89702
91371
  }
89703
91372
 
91373
+ /** A role write refused because the role changed since it was read (HTTP 409). Nothing was saved. */
91374
+ class RoleChangedError extends Error {
91375
+ roleId;
91376
+ constructor(roleId) {
91377
+ super(`Role ${roleId} was changed by someone else since it was read; nothing was saved. Re-run to read it again.`);
91378
+ this.roleId = roleId;
91379
+ }
91380
+ }
91381
+ /**
91382
+ * Roles (2026-11): the catalog (`ess/roles/v1`) and who holds each role (`views/view/{id}`, the
91383
+ * role's DataStore view). Semantics measured on THE_LABORATORY are on the model
91384
+ * (`model/security/roles.ts`).
91385
+ */
91386
+ class RoleService {
91387
+ dxSaaSService;
91388
+ log;
91389
+ constructor(dxSaaSService, log = new Logging.NullSimpleLog()) {
91390
+ this.dxSaaSService = dxSaaSService;
91391
+ this.log = log;
91392
+ }
91393
+ /**
91394
+ * The role catalog: built-in and custom roles with level, description and permission tree.
91395
+ *
91396
+ * @remarks Response-validated, not thrown.
91397
+ */
91398
+ async listRoles() {
91399
+ const raw = await this.dxSaaSService.oiGet('ess/roles/v1', { cohort: cohortGuid(this.dxSaaSService.getCohortIDForURL()) });
91400
+ const result = RoleCatalogSchema.safeParse(raw);
91401
+ if (!result.success)
91402
+ this.log.warn('Role catalog validation warning:', result.error.message);
91403
+ return (raw ?? []);
91404
+ }
91405
+ /**
91406
+ * Every role's view (`attributes.owner: 'DP'`), with its holders.
91407
+ *
91408
+ * @remarks Response-validated, not thrown.
91409
+ */
91410
+ async listRoleViews() {
91411
+ const raw = await this.dxSaaSService.tenantGet('views/view');
91412
+ const views = (raw?.items ?? []).filter((v) => v.attributes?.owner === 'DP');
91413
+ for (const v of views) {
91414
+ const result = RoleViewSchema.safeParse(v);
91415
+ if (!result.success)
91416
+ this.log.warn('RoleView validation warning:', result.error.message);
91417
+ }
91418
+ return views;
91419
+ }
91420
+ /**
91421
+ * One role's view, with its holders and its concurrency token.
91422
+ *
91423
+ * @remarks Response-validated, not thrown.
91424
+ */
91425
+ async getRoleView(roleId) {
91426
+ const raw = await this.dxSaaSService.tenantGet(`views/view/${encodeURIComponent(roleId)}`);
91427
+ const result = RoleViewSchema.safeParse(raw);
91428
+ if (!result.success)
91429
+ this.log.warn('RoleView validation warning:', result.error.message);
91430
+ return raw;
91431
+ }
91432
+ /**
91433
+ * Saves a role's view — in practice its holders (`access`). `view` must carry the
91434
+ * `lastModificationTimestamp` it was read with: a role changed since is refused by the server.
91435
+ *
91436
+ * @throws ZodError for a malformed view; RoleChangedError when the role changed since it was read.
91437
+ */
91438
+ async saveRoleView(view) {
91439
+ RoleViewSchema.parse(view);
91440
+ try {
91441
+ const raw = await this.dxSaaSService.tenantPut(`views/view/${encodeURIComponent(view.viewId)}`, view);
91442
+ const result = RoleViewSchema.safeParse(raw);
91443
+ if (!result.success)
91444
+ this.log.warn('RoleView save validation warning:', result.error.message);
91445
+ return raw;
91446
+ }
91447
+ catch (e) {
91448
+ if (e.httpCode === 409)
91449
+ throw new RoleChangedError(view.viewId);
91450
+ throw e;
91451
+ }
91452
+ }
91453
+ }
91454
+ /** The cohort id in upper-cased, dashed GUID form (`8-4-4-4-12`) the ess endpoints take. */
91455
+ function cohortGuid(cohortId) {
91456
+ const hex = cohortId.replace(/-/g, '').toUpperCase();
91457
+ return [hex.slice(0, 8), hex.slice(8, 12), hex.slice(12, 16), hex.slice(16, 20), hex.slice(20, 32)].join('-');
91458
+ }
91459
+
91460
+ const BASE$1 = 'synthetics/permission-service/api/v1/policies';
91461
+ /**
91462
+ * Synthetics access policies (2026-11): who may READ or WRITE the monitors of a monitor group.
91463
+ * Semantics measured on THE_LABORATORY are on the model (`model/synthetics/access-policy.ts`);
91464
+ * plan a grant or revoke with `planAccessChange` and apply it with one of these calls.
91465
+ */
91466
+ class SyntheticAccessService {
91467
+ dxSaaSService;
91468
+ log;
91469
+ constructor(dxSaaSService, log = new Logging.NullSimpleLog()) {
91470
+ this.dxSaaSService = dxSaaSService;
91471
+ this.log = log;
91472
+ }
91473
+ /**
91474
+ * Every access policy.
91475
+ *
91476
+ * @remarks Response-validated, not thrown.
91477
+ */
91478
+ async listPolicies() {
91479
+ const raw = await this.dxSaaSService.tenantGet(BASE$1);
91480
+ const result = SyntheticAccessPolicyListSchema.safeParse(raw);
91481
+ if (!result.success)
91482
+ this.log.warn('SyntheticAccessPolicy list validation warning:', result.error.message);
91483
+ return (raw ?? []);
91484
+ }
91485
+ /**
91486
+ * Creates a policy. The server answers 400 when the name is taken; it does not check that the
91487
+ * named groups or users exist.
91488
+ *
91489
+ * @throws ZodError for a malformed body.
91490
+ */
91491
+ async createPolicy(body) {
91492
+ SyntheticAccessPolicyWriteSchema.parse(body);
91493
+ const raw = await this.dxSaaSService.tenantPost(BASE$1, body);
91494
+ const result = SyntheticAccessPolicySchema.safeParse(raw);
91495
+ if (!result.success)
91496
+ this.log.warn('SyntheticAccessPolicy create validation warning:', result.error.message);
91497
+ return raw;
91498
+ }
91499
+ /**
91500
+ * Replaces a policy in place (same id) — atomic, unlike the UI's delete-and-recreate.
91501
+ *
91502
+ * @throws ZodError for a malformed body.
91503
+ */
91504
+ async updatePolicy(id, body) {
91505
+ SyntheticAccessPolicyWriteSchema.parse(body);
91506
+ const raw = await this.dxSaaSService.tenantPut(`${BASE$1}/${id}`, { ...body, id });
91507
+ const result = SyntheticAccessPolicySchema.safeParse(raw);
91508
+ if (!result.success)
91509
+ this.log.warn('SyntheticAccessPolicy update validation warning:', result.error.message);
91510
+ return raw;
91511
+ }
91512
+ /** Deletes a policy (204). */
91513
+ async deletePolicy(id) {
91514
+ await this.dxSaaSService.tenantDelete(`${BASE$1}/${id}`);
91515
+ }
91516
+ }
91517
+
91518
+ const BASE = 'ess/usergroups/v1';
91519
+ /**
91520
+ * User groups (`ess/usergroups/v1`, 2026-11). Semantics measured on THE_LABORATORY are on the model
91521
+ * (`model/security/user-groups.ts`); the one to remember: roles and synthetics access name a group
91522
+ * by its name, and nothing follows a rename or a delete.
91523
+ */
91524
+ class UserGroupService {
91525
+ dxSaaSService;
91526
+ log;
91527
+ constructor(dxSaaSService, log = new Logging.NullSimpleLog()) {
91528
+ this.dxSaaSService = dxSaaSService;
91529
+ this.log = log;
91530
+ }
91531
+ /**
91532
+ * Every group, without members.
91533
+ *
91534
+ * @remarks Response-validated, not thrown.
91535
+ */
91536
+ async listGroups() {
91537
+ const raw = await this.dxSaaSService.oiGet(`${BASE}/list`);
91538
+ const result = UserGroupListSchema.safeParse(raw);
91539
+ if (!result.success)
91540
+ this.log.warn('UserGroup list validation warning:', result.error.message);
91541
+ return (raw ?? []);
91542
+ }
91543
+ /**
91544
+ * One group with its member ids and member details.
91545
+ *
91546
+ * @remarks Response-validated, not thrown.
91547
+ */
91548
+ async getGroup(groupId) {
91549
+ const raw = await this.dxSaaSService.oiGet(`${BASE}/${groupId}`, {
91550
+ include_userids: true,
91551
+ include_userinfos: true,
91552
+ });
91553
+ const result = UserGroupSchema.safeParse(raw);
91554
+ if (!result.success)
91555
+ this.log.warn('UserGroup validation warning:', result.error.message);
91556
+ return raw;
91557
+ }
91558
+ /**
91559
+ * Every group name a role or an access policy can legitimately reference: the user groups plus
91560
+ * the legacy APM/ACA groups (`/apm/atc/api/private/aca/group`, whose ids are their names; built-in
91561
+ * roles still list some of them). A reference to a name in neither grants nobody.
91562
+ */
91563
+ async knownGroupNames() {
91564
+ const [groups, legacy] = await Promise.all([
91565
+ this.listGroups(),
91566
+ this.dxSaaSService
91567
+ .tenantGet('/apm/atc/api/private/aca/group', { size: 999, groupId: '*' })
91568
+ .catch((e) => {
91569
+ this.log.warn('Legacy group list unavailable:', String(e));
91570
+ return {};
91571
+ }),
91572
+ ]);
91573
+ return {
91574
+ userGroups: groups.map((g) => g.groupName),
91575
+ legacyGroups: (legacy._embedded?.group ?? []).map((g) => g.id ?? '').filter((id) => id !== ''),
91576
+ };
91577
+ }
91578
+ /** A group by exact name, with members; undefined when there is none. */
91579
+ async findGroup(groupName) {
91580
+ const listed = (await this.listGroups()).find((g) => g.groupName === groupName);
91581
+ return listed ? this.getGroup(listed.groupId) : undefined;
91582
+ }
91583
+ /**
91584
+ * Creates a group. The server answers 400 when the name is taken.
91585
+ *
91586
+ * @throws ZodError for an empty name or member id.
91587
+ */
91588
+ async createGroup(body) {
91589
+ UserGroupWriteSchema.parse(body);
91590
+ const raw = await this.dxSaaSService.oiPost(BASE, body);
91591
+ const result = UserGroupSchema.safeParse(raw);
91592
+ if (!result.success)
91593
+ this.log.warn('UserGroup create validation warning:', result.error.message);
91594
+ return raw;
91595
+ }
91596
+ /**
91597
+ * Replaces a group's name, description and COMPLETE member list (a member left out is removed).
91598
+ * A rename does not update the roles or access policies that name the group.
91599
+ *
91600
+ * @throws ZodError for an empty name or member id.
91601
+ */
91602
+ async updateGroup(groupId, body) {
91603
+ UserGroupWriteSchema.parse(body);
91604
+ const raw = await this.dxSaaSService.oiPut(`${BASE}/${groupId}`, { ...body, groupId });
91605
+ const result = UserGroupSchema.safeParse(raw);
91606
+ if (!result.success)
91607
+ this.log.warn('UserGroup update validation warning:', result.error.message);
91608
+ return raw;
91609
+ }
91610
+ /** Deletes a group (204). Roles and access policies that name it keep the name. */
91611
+ async deleteGroup(groupId) {
91612
+ await this.dxSaaSService.oiDelete(`${BASE}/${groupId}`);
91613
+ }
91614
+ }
91615
+
89704
91616
  var FilterOperation;
89705
91617
  (function (FilterOperation) {
89706
91618
  FilterOperation["EQUALS"] = "eq";
@@ -91023,6 +92935,144 @@ class TASService {
91023
92935
  }
91024
92936
  }
91025
92937
 
92938
+ /**
92939
+ * A metric registered with `attributes["@tags"]` must carry the TYPE_TAGS
92940
+ * flag — without it the server treats "@tags" as an ordinary attribute and
92941
+ * registers a metric with the wrong identity. Added here (not in the caller)
92942
+ * so every registration path gets it; idempotent when the flag is already set.
92943
+ * When the metric has no type at all the flag is not invented — schema
92944
+ * validation rejects that case with an explicit message.
92945
+ */
92946
+ function ensureTypeTagsFlag(metric) {
92947
+ if (metric.attributes?.[TAGS_ATTRIBUTE_KEY] === undefined) {
92948
+ return metric;
92949
+ }
92950
+ const normalized = { ...metric };
92951
+ if (normalized.typeEnum !== undefined &&
92952
+ !normalized.typeEnum.includes('TYPE_TAGS')) {
92953
+ normalized.typeEnum = [...normalized.typeEnum, 'TYPE_TAGS'];
92954
+ }
92955
+ if (normalized.type !== undefined &&
92956
+ (normalized.type & METRIC_TYPE_ENUM.TYPE_TAGS) === 0) {
92957
+ normalized.type = normalized.type | METRIC_TYPE_ENUM.TYPE_TAGS;
92958
+ }
92959
+ return normalized;
92960
+ }
92961
+ /**
92962
+ * The server rejects some real typeEnum names (MONITOR_DOUBLE_DURATION,
92963
+ * MONITOR_DOUBLE_PERCENTAGE) but accepts their numeric `type`. A typeEnum
92964
+ * naming one is sent as the composed `type`, ORed into any `type` given.
92965
+ */
92966
+ function typeEnumToNumericWhereNeeded(metric) {
92967
+ const names = metric.typeEnum;
92968
+ if (!names?.some((n) => NUMERIC_ONLY_TYPE_ENUM_NAMES.includes(n))) {
92969
+ return metric;
92970
+ }
92971
+ const known = names.filter((n) => METRIC_TYPE_ENUM_NAMES.includes(n));
92972
+ if (known.length !== names.length) {
92973
+ return metric;
92974
+ }
92975
+ const normalized = {
92976
+ ...metric,
92977
+ type: (metric.type ?? 0) | composeMetricTypeBits(known),
92978
+ };
92979
+ delete normalized.typeEnum;
92980
+ return normalized;
92981
+ }
92982
+ /**
92983
+ * Service for issuing metric metadata queries against the DX SaaS DataStore
92984
+ * API (`/metadata/queryMetric`).
92985
+ *
92986
+ * Requests are validated against {@link MetadataMetricQuerySchema}; responses
92987
+ * are validated against {@link MetadataMetricQueryResponseV2Schema}.
92988
+ * Validation failures on the response side are logged as warnings, not thrown.
92989
+ *
92990
+ * @example
92991
+ * ```ts
92992
+ * const service = new DataStoreMetricsMetadataService(dxSaasService, log);
92993
+ * const response = await service.queryMetric({
92994
+ * specifier: { op: 'ALL' },
92995
+ * clamp: 500,
92996
+ * time: Date.now(),
92997
+ * range: 480000,
92998
+ * includeLive: true,
92999
+ * includeProfile: false,
93000
+ * });
93001
+ * // response.metrics — matching metric descriptors
93002
+ * // response.folders — matching folder descriptors
93003
+ * ```
93004
+ */
93005
+ class DataStoreMetricsMetadataService {
93006
+ dxSaasService;
93007
+ log;
93008
+ /**
93009
+ * @param dxSaasService - An authenticated {@link DxSaasService} instance
93010
+ * configured for the target tenant (provides gateway host and credentials).
93011
+ * @param log - Logger conforming to {@link SimpleLog} from `@dx-do/util`.
93012
+ * Must implement `info`, `warn`, `error`, and `debug` methods.
93013
+ */
93014
+ constructor(dxSaasService, log) {
93015
+ this.dxSaasService = dxSaasService;
93016
+ this.log = log;
93017
+ }
93018
+ /**
93019
+ * Registers one or more metrics via `POST /metadata/registerMetric`.
93020
+ *
93021
+ * @remarks The request is validated against {@link MetricRegisterRequestSchema}.
93022
+ * Metrics carrying an `attributes["@tags"]` array get the TYPE_TAGS flag
93023
+ * added to their type automatically (idempotent). A `typeEnum` naming
93024
+ * MONITOR_DOUBLE_DURATION or MONITOR_DOUBLE_PERCENTAGE, which the server
93025
+ * rejects by name, is sent as the numeric `type`. If the response fails
93026
+ * schema validation, a warning is logged but the raw API response is
93027
+ * still returned.
93028
+ *
93029
+ * @param requestOverrides - Per-call `timeout` / `signal`; registration is
93030
+ * an idempotent upsert, so a caller may safely retry after a timeout.
93031
+ *
93032
+ * @throws ZodError if the request fails schema validation — including the
93033
+ * tag-registration restrictions ("@tags" non-empty, every listed tag
93034
+ * present with a non-empty string value, TYPE_TAGS never set without tags).
93035
+ */
93036
+ async registerMetrics(metrics, sync, requestOverrides = {}) {
93037
+ const body = {
93038
+ metrics: metrics.map((m) => ensureTypeTagsFlag(typeEnumToNumericWhereNeeded(m))),
93039
+ ...(sync !== undefined ? { sync } : {}),
93040
+ };
93041
+ MetricRegisterRequestSchema.parse(body);
93042
+ const raw = await this.dxSaasService.tenantPost('metadata/registerMetric', body, undefined, {}, requestOverrides);
93043
+ const result = MetricRegisterResponseSchema.safeParse(raw);
93044
+ if (!result.success) {
93045
+ this.log.warn('MetricRegisterResponse validation warning:', result.error.message);
93046
+ }
93047
+ return raw;
93048
+ }
93049
+ /** Registers a single metric. Convenience wrapper around {@link registerMetrics}. */
93050
+ async registerMetric(metric, sync, requestOverrides = {}) {
93051
+ return this.registerMetrics([metric], sync, requestOverrides);
93052
+ }
93053
+ /**
93054
+ * POSTs a metadata query to `/metadata/queryMetric` and returns the matching
93055
+ * metric / folder records.
93056
+ *
93057
+ * @remarks The response is **not** guaranteed to match the schema exactly.
93058
+ * If response validation fails, a warning is logged but the raw API
93059
+ * response is still returned (cast to `MetadataMetricQueryResponseV2`).
93060
+ * Callers should handle potentially incomplete or unexpected fields
93061
+ * defensively.
93062
+ *
93063
+ * @throws ZodError if the request fails schema validation.
93064
+ */
93065
+ async queryMetric(query) {
93066
+ MetadataMetricQuerySchema.parse(query);
93067
+ const raw = await this.dxSaasService.tenantPost('metadata/queryMetric', query);
93068
+ const result = MetadataMetricQueryResponseV2Schema.safeParse(raw);
93069
+ if (!result.success) {
93070
+ this.log.warn('MetadataMetricQueryResponseV2 validation warning:', result.error.message);
93071
+ }
93072
+ return raw;
93073
+ }
93074
+ }
93075
+
91026
93076
  var DEFAULT_SERVICE_INVENTORY_REQUEST_BODY = OIService.DEFAULT_SERVICE_INVENTORY_REQUEST_BODY;
91027
93077
  /**
91028
93078
  * Service for OI services: dependency graph, top-level/all services, inventory,
@@ -91188,6 +93238,24 @@ class ServiceService {
91188
93238
  const graph = await this.readServiceGraph(targets);
91189
93239
  return ServiceBulk.planChanges(graph, targets, parsed);
91190
93240
  }
93241
+ /**
93242
+ * Plans `changes` like {@link planServiceChanges}, adding the save set's before-state (a
93243
+ * re-postable body, the undo) and the confirm token a preview prints and an apply checks.
93244
+ * Saves nothing.
93245
+ *
93246
+ * @throws ZodError for malformed changes; Error for an invalid change.
93247
+ */
93248
+ async previewServiceChanges(changes) {
93249
+ const parsed = ServiceBulk.parseChanges(changes);
93250
+ const targets = ServiceBulk.targetsOf(parsed);
93251
+ const graph = await this.readServiceGraph(targets);
93252
+ const { plan } = ServiceBulk.planChanges(graph, targets, parsed);
93253
+ return {
93254
+ plan,
93255
+ before: plan.save.length ? ServiceBulk.bodyFor(graph, plan.save) : { vertices: [], edges: [] },
93256
+ confirm: ServiceBulkSelect.planToken(plan),
93257
+ };
93258
+ }
91191
93259
  /**
91192
93260
  * Previews one set of edits applied to every service a selector picks, saving
91193
93261
  * nothing. Candidates come from `services` / `root` when given, otherwise from
@@ -91579,6 +93647,85 @@ class ServiceService {
91579
93647
  const { body } = await this.buildServiceUpdateBody(serviceName, patch);
91580
93648
  return this.createService(body, { replace: true });
91581
93649
  }
93650
+ /**
93651
+ * Reads a service's Availability KPI and which of its SLIs could be it (see {@link AvailabilityKpi}).
93652
+ *
93653
+ * @remarks An SLI qualifies once its SLO Threshold metric is in the metadata store within the last 24 h, the
93654
+ * check the UI makes; the metric id the KPI points at comes from there.
93655
+ * @throws Error if the service does not exist.
93656
+ */
93657
+ async getAvailabilityKpi(serviceName) {
93658
+ const overview = await this.getServiceOverview(serviceName);
93659
+ const now = DateTime.now();
93660
+ const slis = await this.getServiceSLIs(overview.externalId, serviceName, now.minus({ hours: 1 }), now);
93661
+ const entry = AvailabilityKpi.currentEntry(overview.attributes.metrics);
93662
+ const names = AvailabilityKpi.metricNames(slis, entry);
93663
+ const published = new Map();
93664
+ if (names.length > 0) {
93665
+ const response = await new DataStoreMetricsMetadataService(this.dxSaaSService, this.log).queryMetric({
93666
+ specifier: {
93667
+ op: 'SPEC',
93668
+ sourceNameSpecifier: { op: 'EXACT', names: [AvailabilityKpi.SOURCE], ignoreCase: true },
93669
+ attributeNameSpecifier: { op: 'EXACT', names },
93670
+ },
93671
+ clamp: names.length,
93672
+ time: now.toMillis(),
93673
+ range: AvailabilityKpi.PUBLISHED_WINDOW_MS,
93674
+ });
93675
+ for (const m of response.metrics ?? []) {
93676
+ if (m.attributeName && m.id) {
93677
+ published.set(m.attributeName, {
93678
+ id: m.id,
93679
+ ...(m.firstSeen ? { firstSeen: m.firstSeen } : {}),
93680
+ ...(m.lastSeen ? { lastSeen: m.lastSeen } : {}),
93681
+ });
93682
+ }
93683
+ }
93684
+ }
93685
+ const current = AvailabilityKpi.describeCurrent(entry, slis, published);
93686
+ return {
93687
+ serviceName,
93688
+ ...(current ? { current } : {}),
93689
+ candidates: AvailabilityKpi.candidates(slis, published, entry),
93690
+ };
93691
+ }
93692
+ /**
93693
+ * Builds the store body that sets the service's Availability KPI to one of its SLIs (`sli`: id or name), or clears
93694
+ * it (`sli` null), WITHOUT saving. Re-saves the full subtree like {@link buildServiceUpdateBody}.
93695
+ *
93696
+ * @returns the body, change lines (empty = nothing to change) and blockers (an SLI that cannot be the KPI, an
93697
+ * unknown SLI, nothing to clear); saving with blockers is the caller's error.
93698
+ * @throws Error if the service does not exist.
93699
+ */
93700
+ async buildAvailabilityKpiBody(serviceName, sli) {
93701
+ const kpi = await this.getAvailabilityKpi(serviceName);
93702
+ const blockers = [];
93703
+ const candidate = sli === null ? undefined : AvailabilityKpi.findCandidate(kpi.candidates, sli);
93704
+ if (sli !== null && !candidate) {
93705
+ blockers.push(AvailabilityKpi.notFound(kpi.candidates, sli, serviceName));
93706
+ }
93707
+ else if (candidate && !candidate.eligible) {
93708
+ blockers.push(`SLI '${candidate.sli}' cannot be the availability KPI: ${candidate.reason}`);
93709
+ }
93710
+ const body = await this.buildHierarchyBody(serviceName);
93711
+ const entry = candidate?.eligible ? AvailabilityKpi.entryFor(candidate) : null;
93712
+ const changes = blockers.length > 0
93713
+ ? []
93714
+ : AvailabilityKpi.apply(body, serviceName, entry, {
93715
+ ...(kpi.current?.sli ? { before: kpi.current.sli } : {}),
93716
+ ...(candidate ? { after: candidate.sli } : {}),
93717
+ });
93718
+ if (blockers.length === 0 && changes.length === 0) {
93719
+ blockers.push(sli === null ? 'the service has no availability KPI to clear' : `SLI '${candidate?.sli}' is already the availability KPI`);
93720
+ }
93721
+ return {
93722
+ body,
93723
+ changes,
93724
+ blockers,
93725
+ ...(kpi.current ? { current: kpi.current } : {}),
93726
+ ...(candidate ? { candidate } : {}),
93727
+ };
93728
+ }
91582
93729
  /** Deletes a service by name; optionally deletes child services recursively. */
91583
93730
  async deleteService(serviceName, recursive = false) {
91584
93731
  return this.dxSaaSService.tenantPost('/oi/v2/sa/service/status', { name: serviceName, action: 'delete' }, { recursive });
@@ -91830,17 +93977,33 @@ class SituationService {
91830
93977
  *
91831
93978
  * @remarks Reads every page until the server's `totalCount` (it used to
91832
93979
  * stop at 50; a demo-dev situation had 69). A short read keeps the server's
91833
- * `totalCount` and logs a warning.
93980
+ * `totalCount` and logs a warning. With `propertySearch`, the server keeps
93981
+ * only events whose `propName` contains the text (case-insensitive).
91834
93982
  */
91835
- async getSituationLifecycleEvents(situationId) {
93983
+ async getSituationLifecycleEvents(situationId, options = {}) {
91836
93984
  return readLifecyclePages((pageNumber, pageSize) => this.dxSaaSService.oiPost('oi/v2/api/alarms/lifecycle/_search', {
91837
93985
  alarmId: situationId,
91838
93986
  pageSize,
91839
93987
  pageNumber,
91840
93988
  sortCol: 'timestamp:desc',
91841
93989
  lifeCycleType: 'SITUATION',
93990
+ ...(options.propertySearch ? { searchText: options.propertySearch } : {}),
91842
93991
  }), `situation ${situationId}`, this.log);
91843
93992
  }
93993
+ /**
93994
+ * The server's explanation of a situation (the 2026-11 Details tab): why it opened, its name,
93995
+ * membership and alarm breakdown, timeline, stabilisation and closure reasoning, and a narration.
93996
+ * An unknown id is not an error: check `situationExplanationFound` (model/situations/situation-explain).
93997
+ *
93998
+ * @remarks Response-validated, not thrown.
93999
+ */
94000
+ async explainSituation(situationId) {
94001
+ const raw = await this.dxSaaSService.oiPost(`oi/v2/api/clusteralarms/explain/${encodeURIComponent(situationId)}`, {});
94002
+ const result = SituationExplanationSchema.safeParse(raw);
94003
+ if (!result.success)
94004
+ this.log.warn('SituationExplanation validation warning:', result.error.message);
94005
+ return raw;
94006
+ }
91844
94007
  /** Returns the inspector inspection result for a situation (related alarms, topology). */
91845
94008
  async getSituationInspection(situationId) {
91846
94009
  return this.dxSaaSService.oiPost('oi/v2/api/inspect/situation', {
@@ -92394,144 +94557,6 @@ class DataStoreFeaturesService {
92394
94557
  }
92395
94558
  }
92396
94559
 
92397
- /**
92398
- * A metric registered with `attributes["@tags"]` must carry the TYPE_TAGS
92399
- * flag — without it the server treats "@tags" as an ordinary attribute and
92400
- * registers a metric with the wrong identity. Added here (not in the caller)
92401
- * so every registration path gets it; idempotent when the flag is already set.
92402
- * When the metric has no type at all the flag is not invented — schema
92403
- * validation rejects that case with an explicit message.
92404
- */
92405
- function ensureTypeTagsFlag(metric) {
92406
- if (metric.attributes?.[TAGS_ATTRIBUTE_KEY] === undefined) {
92407
- return metric;
92408
- }
92409
- const normalized = { ...metric };
92410
- if (normalized.typeEnum !== undefined &&
92411
- !normalized.typeEnum.includes('TYPE_TAGS')) {
92412
- normalized.typeEnum = [...normalized.typeEnum, 'TYPE_TAGS'];
92413
- }
92414
- if (normalized.type !== undefined &&
92415
- (normalized.type & METRIC_TYPE_ENUM.TYPE_TAGS) === 0) {
92416
- normalized.type = normalized.type | METRIC_TYPE_ENUM.TYPE_TAGS;
92417
- }
92418
- return normalized;
92419
- }
92420
- /**
92421
- * The server rejects some real typeEnum names (MONITOR_DOUBLE_DURATION,
92422
- * MONITOR_DOUBLE_PERCENTAGE) but accepts their numeric `type`. A typeEnum
92423
- * naming one is sent as the composed `type`, ORed into any `type` given.
92424
- */
92425
- function typeEnumToNumericWhereNeeded(metric) {
92426
- const names = metric.typeEnum;
92427
- if (!names?.some((n) => NUMERIC_ONLY_TYPE_ENUM_NAMES.includes(n))) {
92428
- return metric;
92429
- }
92430
- const known = names.filter((n) => METRIC_TYPE_ENUM_NAMES.includes(n));
92431
- if (known.length !== names.length) {
92432
- return metric;
92433
- }
92434
- const normalized = {
92435
- ...metric,
92436
- type: (metric.type ?? 0) | composeMetricTypeBits(known),
92437
- };
92438
- delete normalized.typeEnum;
92439
- return normalized;
92440
- }
92441
- /**
92442
- * Service for issuing metric metadata queries against the DX SaaS DataStore
92443
- * API (`/metadata/queryMetric`).
92444
- *
92445
- * Requests are validated against {@link MetadataMetricQuerySchema}; responses
92446
- * are validated against {@link MetadataMetricQueryResponseV2Schema}.
92447
- * Validation failures on the response side are logged as warnings, not thrown.
92448
- *
92449
- * @example
92450
- * ```ts
92451
- * const service = new DataStoreMetricsMetadataService(dxSaasService, log);
92452
- * const response = await service.queryMetric({
92453
- * specifier: { op: 'ALL' },
92454
- * clamp: 500,
92455
- * time: Date.now(),
92456
- * range: 480000,
92457
- * includeLive: true,
92458
- * includeProfile: false,
92459
- * });
92460
- * // response.metrics — matching metric descriptors
92461
- * // response.folders — matching folder descriptors
92462
- * ```
92463
- */
92464
- class DataStoreMetricsMetadataService {
92465
- dxSaasService;
92466
- log;
92467
- /**
92468
- * @param dxSaasService - An authenticated {@link DxSaasService} instance
92469
- * configured for the target tenant (provides gateway host and credentials).
92470
- * @param log - Logger conforming to {@link SimpleLog} from `@dx-do/util`.
92471
- * Must implement `info`, `warn`, `error`, and `debug` methods.
92472
- */
92473
- constructor(dxSaasService, log) {
92474
- this.dxSaasService = dxSaasService;
92475
- this.log = log;
92476
- }
92477
- /**
92478
- * Registers one or more metrics via `POST /metadata/registerMetric`.
92479
- *
92480
- * @remarks The request is validated against {@link MetricRegisterRequestSchema}.
92481
- * Metrics carrying an `attributes["@tags"]` array get the TYPE_TAGS flag
92482
- * added to their type automatically (idempotent). A `typeEnum` naming
92483
- * MONITOR_DOUBLE_DURATION or MONITOR_DOUBLE_PERCENTAGE, which the server
92484
- * rejects by name, is sent as the numeric `type`. If the response fails
92485
- * schema validation, a warning is logged but the raw API response is
92486
- * still returned.
92487
- *
92488
- * @param requestOverrides - Per-call `timeout` / `signal`; registration is
92489
- * an idempotent upsert, so a caller may safely retry after a timeout.
92490
- *
92491
- * @throws ZodError if the request fails schema validation — including the
92492
- * tag-registration restrictions ("@tags" non-empty, every listed tag
92493
- * present with a non-empty string value, TYPE_TAGS never set without tags).
92494
- */
92495
- async registerMetrics(metrics, sync, requestOverrides = {}) {
92496
- const body = {
92497
- metrics: metrics.map((m) => ensureTypeTagsFlag(typeEnumToNumericWhereNeeded(m))),
92498
- ...(sync !== undefined ? { sync } : {}),
92499
- };
92500
- MetricRegisterRequestSchema.parse(body);
92501
- const raw = await this.dxSaasService.tenantPost('metadata/registerMetric', body, undefined, {}, requestOverrides);
92502
- const result = MetricRegisterResponseSchema.safeParse(raw);
92503
- if (!result.success) {
92504
- this.log.warn('MetricRegisterResponse validation warning:', result.error.message);
92505
- }
92506
- return raw;
92507
- }
92508
- /** Registers a single metric. Convenience wrapper around {@link registerMetrics}. */
92509
- async registerMetric(metric, sync, requestOverrides = {}) {
92510
- return this.registerMetrics([metric], sync, requestOverrides);
92511
- }
92512
- /**
92513
- * POSTs a metadata query to `/metadata/queryMetric` and returns the matching
92514
- * metric / folder records.
92515
- *
92516
- * @remarks The response is **not** guaranteed to match the schema exactly.
92517
- * If response validation fails, a warning is logged but the raw API
92518
- * response is still returned (cast to `MetadataMetricQueryResponseV2`).
92519
- * Callers should handle potentially incomplete or unexpected fields
92520
- * defensively.
92521
- *
92522
- * @throws ZodError if the request fails schema validation.
92523
- */
92524
- async queryMetric(query) {
92525
- MetadataMetricQuerySchema.parse(query);
92526
- const raw = await this.dxSaasService.tenantPost('metadata/queryMetric', query);
92527
- const result = MetadataMetricQueryResponseV2Schema.safeParse(raw);
92528
- if (!result.success) {
92529
- this.log.warn('MetadataMetricQueryResponseV2 validation warning:', result.error.message);
92530
- }
92531
- return raw;
92532
- }
92533
- }
92534
-
92535
94560
  /** Raw metric series (`metrics/queryMetric`), Zod-validated. */
92536
94561
  class DataStoreMetricDataService {
92537
94562
  dxSaasService;
@@ -93678,6 +95703,10 @@ function createServiceMonolith(dxDoConfiguration, log = new NullSimpleLog()) {
93678
95703
  dxLogsService,
93679
95704
  dxLogMetricService: new LogMetricService(dxSaaSService, dxLogsService, dxNASSService, log),
93680
95705
  dxMaintenanceService: new MaintenanceService(dxSaaSService, log),
95706
+ dxCustomPropertyService: new CustomPropertyService(dxSaaSService, log),
95707
+ dxRoleService: new RoleService(dxSaaSService, log),
95708
+ dxSyntheticAccessService: new SyntheticAccessService(dxSaaSService, log),
95709
+ dxUserGroupService: new UserGroupService(dxSaaSService, log),
93681
95710
  dxManagementModuleService: dxManagementModuleService,
93682
95711
  dxMetricBatchService: new MetricBatchService(dxSaaSService),
93683
95712
  dxMetricGroupingService: new MetricGroupingService(dxSaaSService, dxManagementModuleService),
@@ -93706,5 +95735,5 @@ function createServiceMonolith(dxDoConfiguration, log = new NullSimpleLog()) {
93706
95735
  };
93707
95736
  }
93708
95737
 
93709
- 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, 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, DataStoreMetricDataService, 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, EnrichmentTransfer, 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, LogMetric, LogMetricApply, LogMetricService, LogQuery, LogTypes, LogsService, MAINTENANCE_UI_TIMEZONES, MAINTENANCE_UTC_TIMEZONE, MANAGEMENT_MODULE_TRANSFORM_PRESETS, 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, MaintenanceUiTimeZoneSchema, ManagementModuleExportSchema, ManagementModuleIdSchema, ManagementModuleService, MatchType, MessageTemplateFieldSchema, MessageTemplateFieldsResponseSchema, MetadataMetricQueryResponseV2Schema, MetadataMetricQuerySchema, MetricAnomalyService, MetricAttributeSchema, MetricBatchService, MetricConfigCustomFilterSchema, MetricConfigFilterOrBlockSchema, MetricConfigFilterSchema, MetricDataQuerySchema, MetricDataResponseSchema, MetricDataSeriesSchema, MetricFolderSchema, MetricGroupingFilterRowSchema, MetricGroupingFilterRowsSchema, MetricGroupingPreviewRowSchema, MetricGroupingService, MetricRegisterInputSchema, MetricRegisterRequestSchema, MetricRegisterResponseSchema, MetricRegisterSchema, MetricRegisterSourceSchema, MetricTypeEnumNameSchema, MmMetricGroupFilterSchema, MmMetricGroupSchema, MmMetricRenameSchema, MmMetricSpecSchema, MmNameSpecifierSchema, MmTransformDetectSchema, MmTransformRuleSchema, MmTransformSchema, NASS, NASSService, NUMERIC_ONLY_TYPE_ENUM_NAMES, 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, SYNTHETIC_CHECK_API_PATH, SYNTHETIC_MONITOR_API_PATH, SYNTHETIC_MONITOR_CREATE_EXAMPLES, SYNTHETIC_MONITOR_CREATE_SCHEMAS, SYNTHETIC_MONITOR_DEFAULT_GROUP, SYNTHETIC_MONITOR_EXAMPLE_LOCATION_ID, SYNTHETIC_MONITOR_GROUP_RULES, SYNTHETIC_MONITOR_MAX_LOCATIONS, SYNTHETIC_MONITOR_PARAMS_SCHEMAS, SYNTHETIC_MONITOR_TIMING_LIMITS, SYNTHETIC_MONITOR_TYPES, SYNTHETIC_SCHEDULE_API_PATH, SYNTHETIC_SCHEDULE_DAY_SECONDS, SYNTHETIC_SCHEDULE_UI_DAY_END, SYNTHETIC_SCRIPT_API_PATH, SYNTHETIC_STATION_API_PATH, SYNTHETIC_STATION_FILES_PATH, SYNTHETIC_VARIABLE_STORE_PATH, 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, SyntheticCheckAssetSchema, SyntheticCheckProbeSchema, SyntheticCheckResultSchema, SyntheticCheckRunSchema, SyntheticCheckStageSchema, SyntheticCheckTimingsSchema, SyntheticCheckTransactionSchema, SyntheticCredentialSaveSchema, SyntheticCredentialSchema, SyntheticCredentialTypeSchema, SyntheticCredentialValueSchema, SyntheticLocationListSchema, SyntheticLocationSchema, SyntheticMonitorApiErrorCauseSchema, SyntheticMonitorApiErrorEnvelopeSchema, SyntheticMonitorApiErrorSchema, SyntheticMonitorAuthEncOptionsSchema, SyntheticMonitorAuthenticationTypeSchema, SyntheticMonitorBrowserSchema, SyntheticMonitorBulkFailureSchema, SyntheticMonitorBulkUpdateRequestSchema, SyntheticMonitorBulkUpdateResponseSchema, SyntheticMonitorCipherListSchema, SyntheticMonitorCreateConnectSchema, SyntheticMonitorCreateDnsSchema, SyntheticMonitorCreateFtpSchema, SyntheticMonitorCreateFullpageSchema, SyntheticMonitorCreateHttpSchema, SyntheticMonitorCreateImapSchema, SyntheticMonitorCreateJmeterSchema, SyntheticMonitorCreateLdapSchema, SyntheticMonitorCreatePingSchema, SyntheticMonitorCreatePluginSchema, SyntheticMonitorCreatePop3Schema, SyntheticMonitorCreateSchema, SyntheticMonitorCreateScpSchema, SyntheticMonitorCreateSftpSchema, SyntheticMonitorCreateSmtpSchema, SyntheticMonitorCreateTelnetSchema, SyntheticMonitorCreateTlsSchema, SyntheticMonitorCreateWebdriverSchema, SyntheticMonitorCreateWebsocketSchema, SyntheticMonitorCredentialsTypeSchema, SyntheticMonitorDayOfWeekSchema, SyntheticMonitorDistinctAttributeSchema, SyntheticMonitorDnsMatchSchema, SyntheticMonitorDnsRecordTypeSchema, SyntheticMonitorEncryptionSchema, SyntheticMonitorEntityReferenceSchema, SyntheticMonitorFiltersSchema, SyntheticMonitorFtpConnectionModeSchema, SyntheticMonitorGroupBySchema, SyntheticMonitorGroupSchema, SyntheticMonitorGroupSummarySchema, SyntheticMonitorHeaderSchema, SyntheticMonitorHistoryEntrySchema, SyntheticMonitorHttpMethodSchema, SyntheticMonitorIpVersionSchema, SyntheticMonitorListQuerySchema, SyntheticMonitorListResultSchema, SyntheticMonitorLocationsSchema, SyntheticMonitorOrderBySchema, SyntheticMonitorParametersSchema, SyntheticMonitorParamsConnectSchema, SyntheticMonitorParamsDnsSchema, SyntheticMonitorParamsFtpSchema, SyntheticMonitorParamsFullpageSchema, SyntheticMonitorParamsHttpSchema, SyntheticMonitorParamsImapSchema, SyntheticMonitorParamsJMeterSchema, SyntheticMonitorParamsLdapSchema, SyntheticMonitorParamsPingSchema, SyntheticMonitorParamsPluginSchema, SyntheticMonitorParamsPop3Schema, SyntheticMonitorParamsScpSchema, SyntheticMonitorParamsSftpSchema, SyntheticMonitorParamsSmtpSchema, SyntheticMonitorParamsTelnetSchema, SyntheticMonitorParamsTlsSchema, SyntheticMonitorParamsWebdriverSchema, SyntheticMonitorParamsWebsocketSchema, SyntheticMonitorRemapHostSchema, SyntheticMonitorScheduleSchema, SyntheticMonitorSchema, SyntheticMonitorScriptTypeSchema, SyntheticMonitorService, SyntheticMonitorStateCredentialsSchema, SyntheticMonitorStateSchema, SyntheticMonitorStateTimingSchema, SyntheticMonitorStateVariableSchema, SyntheticMonitorStatusSchema, SyntheticMonitorTimingPatchSchema, SyntheticMonitorTimingReadSchema, SyntheticMonitorTimingSchema, SyntheticMonitorTransactionPatternSchema, SyntheticMonitorTypeInfoListSchema, SyntheticMonitorTypeInfoSchema, SyntheticMonitorTypeOptionsSchema, SyntheticMonitorTypeSchema, SyntheticMonitorUpdateSchema, SyntheticMonitorVariableReferenceSchema, SyntheticMonitorVariableTypeSchema, SyntheticMonitorWritableStatusSchema, SyntheticProxySaveSchema, SyntheticProxySchema, SyntheticProxyUriSchema, SyntheticScheduleSaveSchema, SyntheticScheduleSchema, SyntheticScheduleWindowSchema, SyntheticScriptCreateSchema, SyntheticScriptParameterSchema, SyntheticScriptSchema, SyntheticScriptTypeSchema, SyntheticScriptUpdateSchema, SyntheticVariableSaveSchema, SyntheticVariableSchema, SyntheticVariableTypeSchema, 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, UTC_EQUIVALENT_TIMEZONES, 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, appendSli, appendSloTriplet, attributeFilterTargets, authHeaderValue, buildAlarmFilterUpdateBody, buildAlarmQueueFilterExpression, buildAlarmQueueUpdateBody, buildAlertEntry, buildClusteringPolicyUpdateBody, buildCustomLogPayload, buildEnrichmentRuleUpdateBody, buildInventoryCustomFilter, buildInventoryQueueUpdateBody, buildPolicyFilterExpression, buildSliFunction, buildSloTriplet, buildTemplateRefs, buildUimLogPayload, canonicalTimeZone, capVertexDetail, chunkPayloads, classifyIngestionError, compileTcSourceName, composeMetricTypeBits, convertLegacyConfiguration, createCurlCommand, createCurlScript, createPostmanRequest, createServiceMonolith, customAttributeKeyIssues, decodeMetricTypeBits, defaultItsmPropertyList, defaultRuleName, deriveSliAs, deriveVertexName, describeClusteringCriteria, describeSyntheticMonitorApiError, displayColumnsFor, dottedFileSlot, draftKey, encodeItsmSecret, ensureParallelAlerts, escapeRegExp, evaluate, evaluateTemplate, example, excludedAttributes, exportAlarmRecords, exportFileLabel, exportIncludesToken, expressionPipelineNames, extractComponentGridData, findAlertByTarget, findInventoryGroup, findProduct, findRedactedSecretPaths, findSliByName, flattenAxiosHeaders, formExternalId, getDataStoreSchema, getUserTokenSub, getUserTokenTid, getVertexAttributeValue, getVertexAttributeValueOrNull, hasTypeTagsFlag, hasVertexAttribute, hiddenAuthObjectName, hiddenScheduleName, hiddenScriptName, impliedDxo2Version, incrementVariant, inventoryDisplayColumnsFor, inventoryQueuesOf, inventorySearchRequestBodyExample, inventorySearchResponseBody, isAlarmFilter, isAlarmQueue, isAlarmQueueNotFound, isAuthorizationHeader, isBuiltInClusteringPolicy, isBuiltInPolicy, isBuiltInTemplate, isDataStoreSchemaType, isEmptyCriteria, isInventoryQueueNotFound, isKnownTimeZone, isMaintenanceUiTimezone, isMonitorOwnedAuthObject, isMonitorOwnedSchedule, isPersonalQueue, isProductProvisioned, isSyntheticMonitorDefaultGroup, isTemplate, isTenantToken, isUserToken, isWildcardOnlySourceName, itsmMapToProperties, itsmPropertiesToMap, javaFullMatch, javaRegexToJs, javaReplaceAll, javaReplaceFirst, javaSplit, lintSourceName, listDataStoreSchemaOps, listNameSpecifierOps, listSlis, logIngestionURLForGateway, maintenanceFilter, markServiceMetricPresence, measureBytes, messageTemplateVariables, metricGroupingCustomFilter, metricGroupingFilter, normalizeAlarmQueueSharing, orBlocksByField, parseAlarmRecordTime, parseExpression, parseExternalIdFormat, parseFilter, parseSaasGateway, parseServiceNowUrl, parseSyntheticMonitorNdjson, pipeGroupRanges, planEnrichmentReorder, policyCategoryGuard, policyFieldBounds, policyFilterAtoms, producedMetricName, projectCustomAttributes, projectRule, pruneOrphanSloFunctions, readLifecyclePages, redactChannelSecrets, reencodeItsmForWrite, relinkDanglingAlertGroups, removeAlert, removeSli, removeSloTriplet, reportingIntervalSeconds, resolveAnomalyDetectionProduct, resolveEnrichmentMappings, resolveWebhookPayload, sampleServiceDetailRequestBody, searchAlarmWindows, searchUniverse, sendWithRetry, serviceDetailResponseBody, sharedRoleDelta, sleep, sliHumanName, sloTripletFor, smallestResolutionAtLeast, sortRulesByPriority, sourceNameBattery, sourceNameMatrix, splitAttributePath, splitTemplate, standardVertexAttributes, summarizeDataStoreSchema, syntheticMonitorQueryString, syntheticScriptExtension, tcSourceNameMatches, tcSourceNameToJavaRegex, tcSourceNameToMmPattern, templateUsage, tenantConfigAttribute, toAlarmFilterWriteBody, toAlarmQueueWriteBody, toAnomalyDetectionGroupSaveRequest, toAnomalyGroupMetricsRequest, toChannelWriteBody, toClusteringPolicyPreviewBody, toClusteringPolicyWriteBody, toEnrichmentRuleCreateBody, toGroupMetricsRequest, toInventoryQueueWriteBody, toItsmTestConnectionRequest, toPolicyWriteBody, toSliGroupSaveRequest, toSyntheticMonitorCreateWireBody, toTemplateWriteBody, toTicketEnrichmentWriteBody, tokenize, transformManagementModule, translateRuleToMmQuery, truthy, unwrapSyntheticMonitorApiError, verifyAndDumpLegacyConfiguration, verifyAndDumpVersion3Configuration, verifyAndDumpVersion4Configuration, vertexMatchesFilters, visibleAlarmQueueColumns, visibleInventoryColumns };
95738
+ 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, 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, AvailabilityKpi, AxaService, BUILT_IN_ROLE_IDS, 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, CUSTOM_PROPERTY_NAME_PATTERN, CUSTOM_PROPERTY_VALUE_TYPES, 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, CustomPropertyAllowedValueSchema, CustomPropertyDefinitionListSchema, CustomPropertyDefinitionSchema, CustomPropertyService, CustomPropertyUsageSchema, CustomPropertyValueTypeSchema, CustomPropertyWriteResponseSchema, CustomPropertyWriteSchema, 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, DataStoreMetricDataService, 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, EnrichmentTransfer, 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, GRID_MACHINE_COLUMNS, GRID_SERVICE_COLUMN, 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, LogMetric, LogMetricApply, LogMetricService, LogQuery, LogTypes, LogsService, MAINTENANCE_UI_TIMEZONES, MAINTENANCE_UTC_TIMEZONE, MANAGEMENT_MODULE_TRANSFORM_PRESETS, 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, MaintenanceUiTimeZoneSchema, ManagementModuleExportSchema, ManagementModuleIdSchema, ManagementModuleService, MatchType, MessageTemplateFieldSchema, MessageTemplateFieldsResponseSchema, MetadataMetricQueryResponseV2Schema, MetadataMetricQuerySchema, MetricAnomalyService, MetricAttributeSchema, MetricBatchService, MetricConfigCustomFilterSchema, MetricConfigFilterOrBlockSchema, MetricConfigFilterSchema, MetricDataQuerySchema, MetricDataResponseSchema, MetricDataSeriesSchema, MetricFolderSchema, MetricGroupingFilterRowSchema, MetricGroupingFilterRowsSchema, MetricGroupingPreviewRowSchema, MetricGroupingService, MetricRegisterInputSchema, MetricRegisterRequestSchema, MetricRegisterResponseSchema, MetricRegisterSchema, MetricRegisterSourceSchema, MetricTypeEnumNameSchema, MmMetricGroupFilterSchema, MmMetricGroupSchema, MmMetricRenameSchema, MmMetricSpecSchema, MmNameSpecifierSchema, MmTransformDetectSchema, MmTransformRuleSchema, MmTransformSchema, NASS, NASSService, NUMERIC_ONLY_TYPE_ENUM_NAMES, 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, PROPERTY_COVERAGE_SCOPE, PROPERTY_GRID_FORMAT, 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, ROLE_GRANT_PERMISSIONS, RecurrencePattern, RevokeTokenRequestSchema, RevokeTokensResponseSchema, RoleCatalogEntrySchema, RoleCatalogSchema, RoleChangedError, RoleGrantSchema, RoleService, RoleViewSchema, SERVICE_METRIC_PRESENCE_WINDOW_MS, SERVICE_PROPERTY_FIELD_PREFIX, SITUATION_EXPLAIN_ALARM_LIST_MAX, SLIService, SLI_DERIVED_METRIC_SOURCE, SMTP_DEFAULT_TEMPLATES, SOURCENAME_DIALECT_CATALOG, SQLService, SYNTHETIC_ACCESS_ACTIONS, SYNTHETIC_ACCESS_SUBJECTS, SYNTHETIC_CHECK_API_PATH, SYNTHETIC_MONITOR_API_PATH, SYNTHETIC_MONITOR_CREATE_EXAMPLES, SYNTHETIC_MONITOR_CREATE_SCHEMAS, SYNTHETIC_MONITOR_DEFAULT_GROUP, SYNTHETIC_MONITOR_EXAMPLE_LOCATION_ID, SYNTHETIC_MONITOR_GROUP_RULES, SYNTHETIC_MONITOR_MAX_LOCATIONS, SYNTHETIC_MONITOR_PARAMS_SCHEMAS, SYNTHETIC_MONITOR_TIMING_LIMITS, SYNTHETIC_MONITOR_TYPES, SYNTHETIC_SCHEDULE_API_PATH, SYNTHETIC_SCHEDULE_DAY_SECONDS, SYNTHETIC_SCHEDULE_UI_DAY_END, SYNTHETIC_SCRIPT_API_PATH, SYNTHETIC_STATION_API_PATH, SYNTHETIC_STATION_FILES_PATH, SYNTHETIC_VARIABLE_STORE_PATH, 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, SituationExplainAlarmSchema, SituationExplainBreakdownSchema, SituationExplainClosureSchema, SituationExplainCreationSchema, SituationExplainIdentitySchema, SituationExplainMembershipSchema, SituationExplainNameSchema, SituationExplainNarrationSchema, SituationExplainStabilizationSchema, SituationExplainTimelineEntrySchema, SituationExplanationSchema, 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, SyntheticAccessPolicyListSchema, SyntheticAccessPolicySchema, SyntheticAccessPolicyWriteSchema, SyntheticAccessRuleSchema, SyntheticAccessService, SyntheticCheckAssetSchema, SyntheticCheckProbeSchema, SyntheticCheckResultSchema, SyntheticCheckRunSchema, SyntheticCheckStageSchema, SyntheticCheckTimingsSchema, SyntheticCheckTransactionSchema, SyntheticCredentialSaveSchema, SyntheticCredentialSchema, SyntheticCredentialTypeSchema, SyntheticCredentialValueSchema, SyntheticLocationListSchema, SyntheticLocationSchema, SyntheticMonitorApiErrorCauseSchema, SyntheticMonitorApiErrorEnvelopeSchema, SyntheticMonitorApiErrorSchema, SyntheticMonitorAuthEncOptionsSchema, SyntheticMonitorAuthenticationTypeSchema, SyntheticMonitorBrowserSchema, SyntheticMonitorBulkFailureSchema, SyntheticMonitorBulkUpdateRequestSchema, SyntheticMonitorBulkUpdateResponseSchema, SyntheticMonitorCipherListSchema, SyntheticMonitorCreateConnectSchema, SyntheticMonitorCreateDnsSchema, SyntheticMonitorCreateFtpSchema, SyntheticMonitorCreateFullpageSchema, SyntheticMonitorCreateHttpSchema, SyntheticMonitorCreateImapSchema, SyntheticMonitorCreateJmeterSchema, SyntheticMonitorCreateLdapSchema, SyntheticMonitorCreatePingSchema, SyntheticMonitorCreatePluginSchema, SyntheticMonitorCreatePop3Schema, SyntheticMonitorCreateSchema, SyntheticMonitorCreateScpSchema, SyntheticMonitorCreateSftpSchema, SyntheticMonitorCreateSmtpSchema, SyntheticMonitorCreateTelnetSchema, SyntheticMonitorCreateTlsSchema, SyntheticMonitorCreateWebdriverSchema, SyntheticMonitorCreateWebsocketSchema, SyntheticMonitorCredentialsTypeSchema, SyntheticMonitorDayOfWeekSchema, SyntheticMonitorDistinctAttributeSchema, SyntheticMonitorDnsMatchSchema, SyntheticMonitorDnsRecordTypeSchema, SyntheticMonitorEncryptionSchema, SyntheticMonitorEntityReferenceSchema, SyntheticMonitorFiltersSchema, SyntheticMonitorFtpConnectionModeSchema, SyntheticMonitorGroupBySchema, SyntheticMonitorGroupSchema, SyntheticMonitorGroupSummarySchema, SyntheticMonitorHeaderSchema, SyntheticMonitorHistoryEntrySchema, SyntheticMonitorHttpMethodSchema, SyntheticMonitorIpVersionSchema, SyntheticMonitorListQuerySchema, SyntheticMonitorListResultSchema, SyntheticMonitorLocationsSchema, SyntheticMonitorOrderBySchema, SyntheticMonitorParametersSchema, SyntheticMonitorParamsConnectSchema, SyntheticMonitorParamsDnsSchema, SyntheticMonitorParamsFtpSchema, SyntheticMonitorParamsFullpageSchema, SyntheticMonitorParamsHttpSchema, SyntheticMonitorParamsImapSchema, SyntheticMonitorParamsJMeterSchema, SyntheticMonitorParamsLdapSchema, SyntheticMonitorParamsPingSchema, SyntheticMonitorParamsPluginSchema, SyntheticMonitorParamsPop3Schema, SyntheticMonitorParamsScpSchema, SyntheticMonitorParamsSftpSchema, SyntheticMonitorParamsSmtpSchema, SyntheticMonitorParamsTelnetSchema, SyntheticMonitorParamsTlsSchema, SyntheticMonitorParamsWebdriverSchema, SyntheticMonitorParamsWebsocketSchema, SyntheticMonitorRemapHostSchema, SyntheticMonitorScheduleSchema, SyntheticMonitorSchema, SyntheticMonitorScriptTypeSchema, SyntheticMonitorService, SyntheticMonitorStateCredentialsSchema, SyntheticMonitorStateSchema, SyntheticMonitorStateTimingSchema, SyntheticMonitorStateVariableSchema, SyntheticMonitorStatusSchema, SyntheticMonitorTimingPatchSchema, SyntheticMonitorTimingReadSchema, SyntheticMonitorTimingSchema, SyntheticMonitorTransactionPatternSchema, SyntheticMonitorTypeInfoListSchema, SyntheticMonitorTypeInfoSchema, SyntheticMonitorTypeOptionsSchema, SyntheticMonitorTypeSchema, SyntheticMonitorUpdateSchema, SyntheticMonitorVariableReferenceSchema, SyntheticMonitorVariableTypeSchema, SyntheticMonitorWritableStatusSchema, SyntheticProxySaveSchema, SyntheticProxySchema, SyntheticProxyUriSchema, SyntheticScheduleSaveSchema, SyntheticScheduleSchema, SyntheticScheduleWindowSchema, SyntheticScriptCreateSchema, SyntheticScriptParameterSchema, SyntheticScriptSchema, SyntheticScriptTypeSchema, SyntheticScriptUpdateSchema, SyntheticVariableSaveSchema, SyntheticVariableSchema, SyntheticVariableTypeSchema, TAGS_ATTRIBUTE_KEY, TAS, TASGraph, TASService, TC_METRIC_CAP, TC_RESERVED_CUSTOM_ATTRIBUTE_KEYS, TC_STANDARD_ATTRIBUTE_KEYS, TENANT_ADMIN_ROLE_ID, 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, UTC_EQUIVALENT_TIMEZONES, UpdateAgentTokenRequestSchema, UpdateTenantTokenRequestSchema, UpdateUserTokenRequestSchema, UserGroupListSchema, UserGroupSchema, UserGroupService, UserGroupUserInfoSchema, UserGroupWriteSchema, 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, accessPolicyBody, accessPolicyName, ags, agsresponse, alarmFilterDisplayColumnsFor, alarmRecordTime, alertsForSliIndex, algorithmicSituationsEnabled, allAlarmQueues, allGroupReferences, appendSli, appendSloTriplet, attributeFilterTargets, authHeaderValue, buildAlarmFilterUpdateBody, buildAlarmQueueFilterExpression, buildAlarmQueueUpdateBody, buildAlertEntry, buildClusteringPolicyUpdateBody, buildCustomLogPayload, buildEnrichmentRuleUpdateBody, buildInventoryCustomFilter, buildInventoryQueueUpdateBody, buildPolicyFilterExpression, buildPropertyGrid, buildSliFunction, buildSloTriplet, buildTemplateRefs, buildUimLogPayload, canonicalTimeZone, capVertexDetail, checkPropertyValue, chunkPayloads, classifyIngestionError, cohortGuid, compileTcSourceName, composeMetricTypeBits, convertLegacyConfiguration, createCurlCommand, createCurlScript, createPostmanRequest, createServiceMonolith, customAttributeKeyIssues, danglingGroupReferences, decodeMetricTypeBits, defaultItsmPropertyList, defaultRuleName, deriveSliAs, deriveVertexName, describeClusteringCriteria, describeSyntheticMonitorApiError, displayColumnsFor, dottedFileSlot, draftKey, editedServices, encodeItsmSecret, ensureParallelAlerts, escapeRegExp, evaluate, evaluateTemplate, example, excludedAttributes, exportAlarmRecords, exportFileLabel, exportIncludesToken, expressionPipelineNames, extractComponentGridData, findAlertByTarget, findInventoryGroup, findProduct, findRedactedSecretPaths, findSliByName, flattenAxiosHeaders, formExternalId, formulaLikeCells, getDataStoreSchema, getUserTokenSub, getUserTokenTid, getVertexAttributeValue, getVertexAttributeValueOrNull, gridToCsv, gridToJson, gridToRows, groupReferences, hasTypeTagsFlag, hasVertexAttribute, hiddenAuthObjectName, hiddenScheduleName, hiddenScriptName, impliedDxo2Version, incrementVariant, inventoryDisplayColumnsFor, inventoryQueuesOf, inventorySearchRequestBodyExample, inventorySearchResponseBody, isAlarmFilter, isAlarmQueue, isAlarmQueueNotFound, isAuthorizationHeader, isBuiltInClusteringPolicy, isBuiltInPolicy, isBuiltInTemplate, isDataStoreSchemaType, isEmptyCriteria, isInventoryQueueNotFound, isKnownTimeZone, isMaintenanceUiTimezone, isMonitorOwnedAuthObject, isMonitorOwnedSchedule, isPersonalQueue, isProductProvisioned, isSyntheticMonitorDefaultGroup, isTemplate, isTenantToken, isUserToken, isWildcardOnlySourceName, itsmMapToProperties, itsmPropertiesToMap, javaFullMatch, javaRegexToJs, javaReplaceAll, javaReplaceFirst, javaSplit, lintSourceName, listDataStoreSchemaOps, listNameSpecifierOps, listSlis, logIngestionURLForGateway, maintenanceFilter, markServiceMetricPresence, measureBytes, messageTemplateVariables, metricGroupingCustomFilter, metricGroupingFilter, missingKeyEffect, namingOperationSignature, namingTemplateProblems, normalizeAlarmQueueSharing, orBlocksByField, parseAlarmRecordTime, parseCsv, parseExpression, parseExternalIdFormat, parseFilter, parseGridRows, parseNamingTemplate, parsePropertyGrid, parseSaasGateway, parseServiceNowUrl, parseSyntheticMonitorNdjson, pipeGroupRanges, planAccessChange, planEnrichmentReorder, planPropertyGridImport, policyCategoryGuard, policyFieldBounds, policyFilterAtoms, policyGrant, producedMetricName, projectCustomAttributes, projectRule, propertyCoverage, propertyRoutingExposure, pruneOrphanSloFunctions, readLifecyclePages, redactChannelSecrets, reencodeItsmForWrite, relinkDanglingAlertGroups, removeAlert, removeSli, removeSloTriplet, reportingIntervalSeconds, resolveAnomalyDetectionProduct, resolveEnrichmentMappings, resolveWebhookPayload, roleHolders, sampleServiceDetailRequestBody, searchAlarmWindows, searchUniverse, sendWithRetry, serviceDetailResponseBody, sharedRoleDelta, situationExplanationFound, sleep, sliHumanName, sloTripletFor, smallestResolutionAtLeast, sortRulesByPriority, sourceNameBattery, sourceNameMatrix, splitAttributePath, splitTemplate, spreadsheetMangling, standardVertexAttributes, summarizeDataStoreSchema, syntheticMonitorQueryString, syntheticScriptExtension, tcSourceNameMatches, tcSourceNameToJavaRegex, tcSourceNameToMmPattern, templateUsage, tenantConfigAttribute, toAlarmFilterWriteBody, toAlarmQueueWriteBody, toAnomalyDetectionGroupSaveRequest, toAnomalyGroupMetricsRequest, toChannelWriteBody, toClusteringPolicyPreviewBody, toClusteringPolicyWriteBody, toDefinitionWrite, toEnrichmentRuleCreateBody, toGroupMetricsRequest, toInventoryQueueWriteBody, toItsmTestConnectionRequest, toPolicyWriteBody, toSliGroupSaveRequest, toSyntheticMonitorCreateWireBody, toTemplateWriteBody, toTicketEnrichmentWriteBody, tokenize, transformManagementModule, translateRuleToMmQuery, truthy, unwrapSyntheticMonitorApiError, verifyAndDumpLegacyConfiguration, verifyAndDumpVersion3Configuration, verifyAndDumpVersion4Configuration, vertexMatchesFilters, visibleAlarmQueueColumns, visibleInventoryColumns, withGraphProperties, withRoleGrant, withoutRoleGrant };
93710
95739
  //# sourceMappingURL=index.esm.js.map