@redocly/config 0.49.0 → 0.50.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 (41) hide show
  1. package/lib/asyncapi-config-schema.d.ts +106 -106
  2. package/lib/common.d.ts +158 -135
  3. package/lib/constants/config.d.ts +10 -10
  4. package/lib/constants/entities.d.ts +21 -43
  5. package/lib/constants/identity-provider-slug.d.ts +8 -0
  6. package/lib/default-theme-config-schema.d.ts +3534 -3488
  7. package/lib/entities-catalog-config-schema.d.ts +469 -469
  8. package/lib/entities-catalog-entity-file-schema.d.ts +441 -441
  9. package/lib/ex-theme-config-schemas.d.ts +3020 -2997
  10. package/lib/feedback-config-schema.d.ts +99 -99
  11. package/lib/graphql-config-schema.d.ts +165 -165
  12. package/lib/index.d.ts +1 -0
  13. package/lib/index.js +1 -1
  14. package/lib/product-override-schema.d.ts +11541 -11518
  15. package/lib/redoc-config-schema.d.ts +155 -155
  16. package/lib/reference-docs-config-schema.d.ts +481 -481
  17. package/lib/reunite-config-schema.d.ts +41 -41
  18. package/lib/root-config-schema.d.ts +52200 -51598
  19. package/lib/scorecards-config-schema.d.ts +405 -405
  20. package/lib/types/config-types.d.ts +5 -1
  21. package/lib-esm/asyncapi-config-schema.d.ts +106 -106
  22. package/lib-esm/common.d.ts +158 -135
  23. package/lib-esm/constants/config.d.ts +10 -10
  24. package/lib-esm/constants/entities.d.ts +21 -43
  25. package/lib-esm/constants/identity-provider-slug.d.ts +8 -0
  26. package/lib-esm/default-theme-config-schema.d.ts +3534 -3488
  27. package/lib-esm/entities-catalog-config-schema.d.ts +469 -469
  28. package/lib-esm/entities-catalog-entity-file-schema.d.ts +441 -441
  29. package/lib-esm/ex-theme-config-schemas.d.ts +3020 -2997
  30. package/lib-esm/feedback-config-schema.d.ts +99 -99
  31. package/lib-esm/graphql-config-schema.d.ts +165 -165
  32. package/lib-esm/index.d.ts +1 -0
  33. package/lib-esm/index.js +1 -1
  34. package/lib-esm/product-override-schema.d.ts +11541 -11518
  35. package/lib-esm/redoc-config-schema.d.ts +155 -155
  36. package/lib-esm/reference-docs-config-schema.d.ts +481 -481
  37. package/lib-esm/reunite-config-schema.d.ts +41 -41
  38. package/lib-esm/root-config-schema.d.ts +52200 -51598
  39. package/lib-esm/scorecards-config-schema.d.ts +405 -405
  40. package/lib-esm/types/config-types.d.ts +5 -1
  41. package/package.json +9 -9
package/lib-esm/scorecards-config-schema.d.ts CHANGED
@@ -1,189 +1,189 @@
1
1
  export declare const scorecardSchema: {
2
- readonly type: "object";
2
+ readonly type: 'object';
3
3
  readonly properties: {
4
4
  readonly name: {
5
- readonly type: "string";
5
+ readonly type: 'string';
6
6
  };
7
7
  readonly key: {
8
- readonly type: "string";
8
+ readonly type: 'string';
9
9
  };
10
10
  readonly description: {
11
- readonly type: "string";
11
+ readonly type: 'string';
12
12
  };
13
13
  readonly entities: {
14
14
  readonly oneOf: readonly [{
15
- readonly type: "array";
15
+ readonly type: 'array';
16
16
  readonly items: {
17
17
  readonly oneOf: readonly [{
18
- readonly type: "object";
18
+ readonly type: 'object';
19
19
  readonly properties: {
20
20
  readonly field: {
21
- readonly type: "string";
21
+ readonly type: 'string';
22
22
  };
23
23
  readonly operator: {
24
- readonly type: "string";
25
- readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
24
+ readonly type: 'string';
25
+ readonly enum: readonly ['eq', 'in', 'gt', 'gte', 'lt', 'lte', 'contains', 'startsWith', 'endsWith', 'exists', 'isEmpty', 'between', 'matches', 'some', 'every', 'none'];
26
26
  };
27
27
  readonly value: {
28
28
  readonly oneOf: readonly [{
29
- readonly type: "boolean";
29
+ readonly type: 'boolean';
30
30
  }, {
31
- readonly type: "string";
31
+ readonly type: 'string';
32
32
  }, {
33
- readonly type: "number";
33
+ readonly type: 'number';
34
34
  }];
35
35
  };
36
36
  readonly modifier: {
37
- readonly type: "string";
38
- readonly enum: readonly ["not"];
37
+ readonly type: 'string';
38
+ readonly enum: readonly ['not'];
39
39
  };
40
40
  readonly match: {
41
- readonly type: "array";
41
+ readonly type: 'array';
42
42
  readonly items: {
43
- readonly type: "object";
43
+ readonly type: 'object';
44
44
  readonly properties: {
45
45
  readonly field: {
46
- readonly type: "string";
46
+ readonly type: 'string';
47
47
  };
48
48
  readonly operator: {
49
- readonly type: "string";
50
- readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
49
+ readonly type: 'string';
50
+ readonly enum: readonly ['eq', 'in', 'gt', 'gte', 'lt', 'lte', 'contains', 'startsWith', 'endsWith', 'exists', 'isEmpty', 'between', 'matches', 'some', 'every', 'none'];
51
51
  };
52
52
  readonly value: {
53
53
  readonly oneOf: readonly [{
54
- readonly type: "boolean";
54
+ readonly type: 'boolean';
55
55
  }, {
56
- readonly type: "string";
56
+ readonly type: 'string';
57
57
  }, {
58
- readonly type: "number";
58
+ readonly type: 'number';
59
59
  }];
60
60
  };
61
61
  readonly modifier: {
62
- readonly type: "string";
63
- readonly enum: readonly ["not"];
62
+ readonly type: 'string';
63
+ readonly enum: readonly ['not'];
64
64
  };
65
65
  };
66
66
  };
67
67
  };
68
68
  };
69
69
  }, {
70
- readonly type: "object";
70
+ readonly type: 'object';
71
71
  readonly properties: {
72
72
  readonly operator: {
73
- readonly type: "string";
74
- readonly enum: readonly ["and", "or"];
73
+ readonly type: 'string';
74
+ readonly enum: readonly ['and', 'or'];
75
75
  };
76
76
  readonly conditions: {
77
- readonly type: "array";
77
+ readonly type: 'array';
78
78
  readonly items: {
79
79
  readonly oneOf: readonly [{
80
- readonly type: "object";
80
+ readonly type: 'object';
81
81
  readonly properties: {
82
82
  readonly field: {
83
- readonly type: "string";
83
+ readonly type: 'string';
84
84
  };
85
85
  readonly operator: {
86
- readonly type: "string";
87
- readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
86
+ readonly type: 'string';
87
+ readonly enum: readonly ['eq', 'in', 'gt', 'gte', 'lt', 'lte', 'contains', 'startsWith', 'endsWith', 'exists', 'isEmpty', 'between', 'matches', 'some', 'every', 'none'];
88
88
  };
89
89
  readonly value: {
90
90
  readonly oneOf: readonly [{
91
- readonly type: "boolean";
91
+ readonly type: 'boolean';
92
92
  }, {
93
- readonly type: "string";
93
+ readonly type: 'string';
94
94
  }, {
95
- readonly type: "number";
95
+ readonly type: 'number';
96
96
  }];
97
97
  };
98
98
  readonly modifier: {
99
- readonly type: "string";
100
- readonly enum: readonly ["not"];
99
+ readonly type: 'string';
100
+ readonly enum: readonly ['not'];
101
101
  };
102
102
  readonly match: {
103
- readonly type: "array";
103
+ readonly type: 'array';
104
104
  readonly items: {
105
- readonly type: "object";
105
+ readonly type: 'object';
106
106
  readonly properties: {
107
107
  readonly field: {
108
- readonly type: "string";
108
+ readonly type: 'string';
109
109
  };
110
110
  readonly operator: {
111
- readonly type: "string";
112
- readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
111
+ readonly type: 'string';
112
+ readonly enum: readonly ['eq', 'in', 'gt', 'gte', 'lt', 'lte', 'contains', 'startsWith', 'endsWith', 'exists', 'isEmpty', 'between', 'matches', 'some', 'every', 'none'];
113
113
  };
114
114
  readonly value: {
115
115
  readonly oneOf: readonly [{
116
- readonly type: "boolean";
116
+ readonly type: 'boolean';
117
117
  }, {
118
- readonly type: "string";
118
+ readonly type: 'string';
119
119
  }, {
120
- readonly type: "number";
120
+ readonly type: 'number';
121
121
  }];
122
122
  };
123
123
  readonly modifier: {
124
- readonly type: "string";
125
- readonly enum: readonly ["not"];
124
+ readonly type: 'string';
125
+ readonly enum: readonly ['not'];
126
126
  };
127
127
  };
128
128
  };
129
129
  };
130
130
  };
131
131
  }, {
132
- readonly type: "object";
132
+ readonly type: 'object';
133
133
  readonly properties: {
134
134
  readonly operator: {
135
- readonly type: "string";
136
- readonly enum: readonly ["and", "or"];
135
+ readonly type: 'string';
136
+ readonly enum: readonly ['and', 'or'];
137
137
  };
138
138
  readonly conditions: {
139
- readonly type: "array";
139
+ readonly type: 'array';
140
140
  readonly items: {
141
- readonly type: "object";
141
+ readonly type: 'object';
142
142
  readonly properties: {
143
143
  readonly field: {
144
- readonly type: "string";
144
+ readonly type: 'string';
145
145
  };
146
146
  readonly operator: {
147
- readonly type: "string";
148
- readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
147
+ readonly type: 'string';
148
+ readonly enum: readonly ['eq', 'in', 'gt', 'gte', 'lt', 'lte', 'contains', 'startsWith', 'endsWith', 'exists', 'isEmpty', 'between', 'matches', 'some', 'every', 'none'];
149
149
  };
150
150
  readonly value: {
151
151
  readonly oneOf: readonly [{
152
- readonly type: "boolean";
152
+ readonly type: 'boolean';
153
153
  }, {
154
- readonly type: "string";
154
+ readonly type: 'string';
155
155
  }, {
156
- readonly type: "number";
156
+ readonly type: 'number';
157
157
  }];
158
158
  };
159
159
  readonly modifier: {
160
- readonly type: "string";
161
- readonly enum: readonly ["not"];
160
+ readonly type: 'string';
161
+ readonly enum: readonly ['not'];
162
162
  };
163
163
  readonly match: {
164
- readonly type: "array";
164
+ readonly type: 'array';
165
165
  readonly items: {
166
- readonly type: "object";
166
+ readonly type: 'object';
167
167
  readonly properties: {
168
168
  readonly field: {
169
- readonly type: "string";
169
+ readonly type: 'string';
170
170
  };
171
171
  readonly operator: {
172
- readonly type: "string";
173
- readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
172
+ readonly type: 'string';
173
+ readonly enum: readonly ['eq', 'in', 'gt', 'gte', 'lt', 'lte', 'contains', 'startsWith', 'endsWith', 'exists', 'isEmpty', 'between', 'matches', 'some', 'every', 'none'];
174
174
  };
175
175
  readonly value: {
176
176
  readonly oneOf: readonly [{
177
- readonly type: "boolean";
177
+ readonly type: 'boolean';
178
178
  }, {
179
- readonly type: "string";
179
+ readonly type: 'string';
180
180
  }, {
181
- readonly type: "number";
181
+ readonly type: 'number';
182
182
  }];
183
183
  };
184
184
  readonly modifier: {
185
- readonly type: "string";
186
- readonly enum: readonly ["not"];
185
+ readonly type: 'string';
186
+ readonly enum: readonly ['not'];
187
187
  };
188
188
  };
189
189
  };
@@ -192,196 +192,196 @@ export declare const scorecardSchema: {
192
192
  };
193
193
  };
194
194
  };
195
- readonly required: readonly ["operator", "conditions"];
195
+ readonly required: readonly ['operator', 'conditions'];
196
196
  readonly additionalProperties: false;
197
197
  }];
198
198
  };
199
199
  };
200
200
  };
201
- readonly required: readonly ["operator", "conditions"];
201
+ readonly required: readonly ['operator', 'conditions'];
202
202
  readonly additionalProperties: false;
203
203
  }];
204
204
  };
205
205
  }, {
206
- readonly type: "object";
206
+ readonly type: 'object';
207
207
  readonly properties: {
208
208
  readonly operator: {
209
- readonly type: "string";
210
- readonly enum: readonly ["and", "or"];
209
+ readonly type: 'string';
210
+ readonly enum: readonly ['and', 'or'];
211
211
  };
212
212
  readonly conditions: {
213
- readonly type: "array";
213
+ readonly type: 'array';
214
214
  readonly items: {
215
215
  readonly oneOf: readonly [{
216
- readonly type: "object";
216
+ readonly type: 'object';
217
217
  readonly properties: {
218
218
  readonly field: {
219
- readonly type: "string";
219
+ readonly type: 'string';
220
220
  };
221
221
  readonly operator: {
222
- readonly type: "string";
223
- readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
222
+ readonly type: 'string';
223
+ readonly enum: readonly ['eq', 'in', 'gt', 'gte', 'lt', 'lte', 'contains', 'startsWith', 'endsWith', 'exists', 'isEmpty', 'between', 'matches', 'some', 'every', 'none'];
224
224
  };
225
225
  readonly value: {
226
226
  readonly oneOf: readonly [{
227
- readonly type: "boolean";
227
+ readonly type: 'boolean';
228
228
  }, {
229
- readonly type: "string";
229
+ readonly type: 'string';
230
230
  }, {
231
- readonly type: "number";
231
+ readonly type: 'number';
232
232
  }];
233
233
  };
234
234
  readonly modifier: {
235
- readonly type: "string";
236
- readonly enum: readonly ["not"];
235
+ readonly type: 'string';
236
+ readonly enum: readonly ['not'];
237
237
  };
238
238
  readonly match: {
239
- readonly type: "array";
239
+ readonly type: 'array';
240
240
  readonly items: {
241
- readonly type: "object";
241
+ readonly type: 'object';
242
242
  readonly properties: {
243
243
  readonly field: {
244
- readonly type: "string";
244
+ readonly type: 'string';
245
245
  };
246
246
  readonly operator: {
247
- readonly type: "string";
248
- readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
247
+ readonly type: 'string';
248
+ readonly enum: readonly ['eq', 'in', 'gt', 'gte', 'lt', 'lte', 'contains', 'startsWith', 'endsWith', 'exists', 'isEmpty', 'between', 'matches', 'some', 'every', 'none'];
249
249
  };
250
250
  readonly value: {
251
251
  readonly oneOf: readonly [{
252
- readonly type: "boolean";
252
+ readonly type: 'boolean';
253
253
  }, {
254
- readonly type: "string";
254
+ readonly type: 'string';
255
255
  }, {
256
- readonly type: "number";
256
+ readonly type: 'number';
257
257
  }];
258
258
  };
259
259
  readonly modifier: {
260
- readonly type: "string";
261
- readonly enum: readonly ["not"];
260
+ readonly type: 'string';
261
+ readonly enum: readonly ['not'];
262
262
  };
263
263
  };
264
264
  };
265
265
  };
266
266
  };
267
267
  }, {
268
- readonly type: "object";
268
+ readonly type: 'object';
269
269
  readonly properties: {
270
270
  readonly operator: {
271
- readonly type: "string";
272
- readonly enum: readonly ["and", "or"];
271
+ readonly type: 'string';
272
+ readonly enum: readonly ['and', 'or'];
273
273
  };
274
274
  readonly conditions: {
275
- readonly type: "array";
275
+ readonly type: 'array';
276
276
  readonly items: {
277
277
  readonly oneOf: readonly [{
278
- readonly type: "object";
278
+ readonly type: 'object';
279
279
  readonly properties: {
280
280
  readonly field: {
281
- readonly type: "string";
281
+ readonly type: 'string';
282
282
  };
283
283
  readonly operator: {
284
- readonly type: "string";
285
- readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
284
+ readonly type: 'string';
285
+ readonly enum: readonly ['eq', 'in', 'gt', 'gte', 'lt', 'lte', 'contains', 'startsWith', 'endsWith', 'exists', 'isEmpty', 'between', 'matches', 'some', 'every', 'none'];
286
286
  };
287
287
  readonly value: {
288
288
  readonly oneOf: readonly [{
289
- readonly type: "boolean";
289
+ readonly type: 'boolean';
290
290
  }, {
291
- readonly type: "string";
291
+ readonly type: 'string';
292
292
  }, {
293
- readonly type: "number";
293
+ readonly type: 'number';
294
294
  }];
295
295
  };
296
296
  readonly modifier: {
297
- readonly type: "string";
298
- readonly enum: readonly ["not"];
297
+ readonly type: 'string';
298
+ readonly enum: readonly ['not'];
299
299
  };
300
300
  readonly match: {
301
- readonly type: "array";
301
+ readonly type: 'array';
302
302
  readonly items: {
303
- readonly type: "object";
303
+ readonly type: 'object';
304
304
  readonly properties: {
305
305
  readonly field: {
306
- readonly type: "string";
306
+ readonly type: 'string';
307
307
  };
308
308
  readonly operator: {
309
- readonly type: "string";
310
- readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
309
+ readonly type: 'string';
310
+ readonly enum: readonly ['eq', 'in', 'gt', 'gte', 'lt', 'lte', 'contains', 'startsWith', 'endsWith', 'exists', 'isEmpty', 'between', 'matches', 'some', 'every', 'none'];
311
311
  };
312
312
  readonly value: {
313
313
  readonly oneOf: readonly [{
314
- readonly type: "boolean";
314
+ readonly type: 'boolean';
315
315
  }, {
316
- readonly type: "string";
316
+ readonly type: 'string';
317
317
  }, {
318
- readonly type: "number";
318
+ readonly type: 'number';
319
319
  }];
320
320
  };
321
321
  readonly modifier: {
322
- readonly type: "string";
323
- readonly enum: readonly ["not"];
322
+ readonly type: 'string';
323
+ readonly enum: readonly ['not'];
324
324
  };
325
325
  };
326
326
  };
327
327
  };
328
328
  };
329
329
  }, {
330
- readonly type: "object";
330
+ readonly type: 'object';
331
331
  readonly properties: {
332
332
  readonly operator: {
333
- readonly type: "string";
334
- readonly enum: readonly ["and", "or"];
333
+ readonly type: 'string';
334
+ readonly enum: readonly ['and', 'or'];
335
335
  };
336
336
  readonly conditions: {
337
- readonly type: "array";
337
+ readonly type: 'array';
338
338
  readonly items: {
339
- readonly type: "object";
339
+ readonly type: 'object';
340
340
  readonly properties: {
341
341
  readonly field: {
342
- readonly type: "string";
342
+ readonly type: 'string';
343
343
  };
344
344
  readonly operator: {
345
- readonly type: "string";
346
- readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
345
+ readonly type: 'string';
346
+ readonly enum: readonly ['eq', 'in', 'gt', 'gte', 'lt', 'lte', 'contains', 'startsWith', 'endsWith', 'exists', 'isEmpty', 'between', 'matches', 'some', 'every', 'none'];
347
347
  };
348
348
  readonly value: {
349
349
  readonly oneOf: readonly [{
350
- readonly type: "boolean";
350
+ readonly type: 'boolean';
351
351
  }, {
352
- readonly type: "string";
352
+ readonly type: 'string';
353
353
  }, {
354
- readonly type: "number";
354
+ readonly type: 'number';
355
355
  }];
356
356
  };
357
357
  readonly modifier: {
358
- readonly type: "string";
359
- readonly enum: readonly ["not"];
358
+ readonly type: 'string';
359
+ readonly enum: readonly ['not'];
360
360
  };
361
361
  readonly match: {
362
- readonly type: "array";
362
+ readonly type: 'array';
363
363
  readonly items: {
364
- readonly type: "object";
364
+ readonly type: 'object';
365
365
  readonly properties: {
366
366
  readonly field: {
367
- readonly type: "string";
367
+ readonly type: 'string';
368
368
  };
369
369
  readonly operator: {
370
- readonly type: "string";
371
- readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
370
+ readonly type: 'string';
371
+ readonly enum: readonly ['eq', 'in', 'gt', 'gte', 'lt', 'lte', 'contains', 'startsWith', 'endsWith', 'exists', 'isEmpty', 'between', 'matches', 'some', 'every', 'none'];
372
372
  };
373
373
  readonly value: {
374
374
  readonly oneOf: readonly [{
375
- readonly type: "boolean";
375
+ readonly type: 'boolean';
376
376
  }, {
377
- readonly type: "string";
377
+ readonly type: 'string';
378
378
  }, {
379
- readonly type: "number";
379
+ readonly type: 'number';
380
380
  }];
381
381
  };
382
382
  readonly modifier: {
383
- readonly type: "string";
384
- readonly enum: readonly ["not"];
383
+ readonly type: 'string';
384
+ readonly enum: readonly ['not'];
385
385
  };
386
386
  };
387
387
  };
@@ -390,394 +390,394 @@ export declare const scorecardSchema: {
390
390
  };
391
391
  };
392
392
  };
393
- readonly required: readonly ["operator", "conditions"];
393
+ readonly required: readonly ['operator', 'conditions'];
394
394
  readonly additionalProperties: false;
395
395
  }];
396
396
  };
397
397
  };
398
398
  };
399
- readonly required: readonly ["operator", "conditions"];
399
+ readonly required: readonly ['operator', 'conditions'];
400
400
  readonly additionalProperties: false;
401
401
  }];
402
402
  };
403
403
  };
404
404
  };
405
- readonly required: readonly ["operator", "conditions"];
405
+ readonly required: readonly ['operator', 'conditions'];
406
406
  readonly additionalProperties: false;
407
407
  }];
408
408
  };
409
409
  readonly levels: {
410
- readonly type: "array";
410
+ readonly type: 'array';
411
411
  readonly items: {
412
- readonly type: "object";
412
+ readonly type: 'object';
413
413
  readonly properties: {
414
414
  readonly name: {
415
- readonly type: "string";
415
+ readonly type: 'string';
416
416
  };
417
417
  readonly extends: {
418
418
  readonly nodeTypeName: undefined;
419
- readonly type: "array";
419
+ readonly type: 'array';
420
420
  readonly items: {
421
- readonly type: "string";
421
+ readonly type: 'string';
422
422
  };
423
- readonly description: "Use extends to inherit rules and their configurations from other rulesets.";
424
- readonly documentationLink: "https://redocly.com/docs/cli/configuration/reference/extends";
423
+ readonly description: 'Use extends to inherit rules and their configurations from other rulesets.';
424
+ readonly documentationLink: 'https://redocly.com/docs/cli/configuration/reference/extends';
425
425
  };
426
426
  readonly rules: {
427
- readonly type: "object";
427
+ readonly type: 'object';
428
428
  readonly additionalProperties: {
429
429
  readonly oneOf: readonly [{
430
- readonly type: "string";
430
+ readonly type: 'string';
431
431
  }, {
432
- readonly type: "object";
432
+ readonly type: 'object';
433
433
  readonly properties: {
434
434
  readonly severity: {
435
- readonly type: "string";
436
- readonly enum: readonly ["error", "warn", "off"];
435
+ readonly type: 'string';
436
+ readonly enum: readonly ['error', 'warn', 'off'];
437
437
  };
438
438
  readonly weight: {
439
- readonly type: "number";
439
+ readonly type: 'number';
440
440
  readonly default: 1;
441
441
  };
442
442
  };
443
443
  readonly additionalProperties: true;
444
444
  }, {
445
- readonly type: "object";
445
+ readonly type: 'object';
446
446
  readonly properties: {
447
447
  readonly title: {
448
- readonly type: "string";
448
+ readonly type: 'string';
449
449
  };
450
450
  readonly subject: {
451
- readonly type: "object";
451
+ readonly type: 'object';
452
452
  readonly properties: {
453
453
  readonly type: {
454
- readonly type: "string";
455
- readonly enum: readonly ["Entity", "EntityMetadata", "EntityRelations", "EntityRelation"];
454
+ readonly type: 'string';
455
+ readonly enum: readonly ['Entity', 'EntityMetadata', 'EntityRelations', 'EntityRelation'];
456
456
  };
457
457
  readonly property: {
458
- readonly type: "string";
458
+ readonly type: 'string';
459
459
  };
460
460
  };
461
- readonly required: readonly ["type", "property"];
461
+ readonly required: readonly ['type', 'property'];
462
462
  readonly additionalProperties: false;
463
463
  };
464
464
  readonly severity: {
465
- readonly type: "string";
466
- readonly enum: readonly ["error", "warn", "off"];
465
+ readonly type: 'string';
466
+ readonly enum: readonly ['error', 'warn', 'off'];
467
467
  };
468
468
  readonly message: {
469
- readonly type: "string";
469
+ readonly type: 'string';
470
470
  };
471
471
  readonly assertions: {
472
- readonly type: "object";
472
+ readonly type: 'object';
473
473
  readonly properties: {
474
474
  readonly defined: {
475
- readonly type: "boolean";
475
+ readonly type: 'boolean';
476
476
  };
477
477
  readonly nonEmpty: {
478
- readonly type: "boolean";
478
+ readonly type: 'boolean';
479
479
  };
480
480
  readonly eq: {};
481
481
  readonly gt: {
482
- readonly type: "number";
482
+ readonly type: 'number';
483
483
  };
484
484
  readonly gte: {
485
- readonly type: "number";
485
+ readonly type: 'number';
486
486
  };
487
487
  readonly lt: {
488
- readonly type: "number";
488
+ readonly type: 'number';
489
489
  };
490
490
  readonly lte: {
491
- readonly type: "number";
491
+ readonly type: 'number';
492
492
  };
493
493
  readonly const: {};
494
494
  };
495
495
  readonly additionalProperties: false;
496
496
  };
497
497
  readonly where: {
498
- readonly type: "array";
498
+ readonly type: 'array';
499
499
  readonly items: {
500
- readonly type: "object";
500
+ readonly type: 'object';
501
501
  readonly properties: {
502
502
  readonly subject: {
503
- readonly type: "object";
503
+ readonly type: 'object';
504
504
  readonly properties: {
505
505
  readonly type: {
506
- readonly type: "string";
507
- readonly enum: readonly ["Entity", "EntityMetadata", "EntityRelations", "EntityRelation"];
506
+ readonly type: 'string';
507
+ readonly enum: readonly ['Entity', 'EntityMetadata', 'EntityRelations', 'EntityRelation'];
508
508
  };
509
509
  readonly property: {
510
- readonly type: "string";
510
+ readonly type: 'string';
511
511
  };
512
512
  };
513
- readonly required: readonly ["type", "property"];
513
+ readonly required: readonly ['type', 'property'];
514
514
  readonly additionalProperties: false;
515
515
  };
516
516
  readonly assertions: {
517
- readonly type: "object";
517
+ readonly type: 'object';
518
518
  readonly properties: {
519
519
  readonly defined: {
520
- readonly type: "boolean";
520
+ readonly type: 'boolean';
521
521
  };
522
522
  readonly nonEmpty: {
523
- readonly type: "boolean";
523
+ readonly type: 'boolean';
524
524
  };
525
525
  readonly eq: {};
526
526
  readonly gt: {
527
- readonly type: "number";
527
+ readonly type: 'number';
528
528
  };
529
529
  readonly gte: {
530
- readonly type: "number";
530
+ readonly type: 'number';
531
531
  };
532
532
  readonly lt: {
533
- readonly type: "number";
533
+ readonly type: 'number';
534
534
  };
535
535
  readonly lte: {
536
- readonly type: "number";
536
+ readonly type: 'number';
537
537
  };
538
538
  readonly const: {};
539
539
  };
540
540
  readonly additionalProperties: false;
541
541
  };
542
542
  };
543
- readonly required: readonly ["subject", "assertions"];
543
+ readonly required: readonly ['subject', 'assertions'];
544
544
  readonly additionalProperties: false;
545
545
  };
546
546
  };
547
547
  readonly weight: {
548
- readonly type: "number";
548
+ readonly type: 'number';
549
549
  readonly default: 1;
550
550
  };
551
551
  };
552
- readonly required: readonly ["subject", "assertions"];
552
+ readonly required: readonly ['subject', 'assertions'];
553
553
  readonly additionalProperties: false;
554
554
  }];
555
555
  };
556
556
  };
557
557
  };
558
- readonly required: readonly ["name"];
558
+ readonly required: readonly ['name'];
559
559
  readonly additionalProperties: false;
560
560
  };
561
561
  readonly minItems: 1;
562
562
  };
563
563
  readonly trigger: {
564
564
  readonly oneOf: readonly [{
565
- readonly type: "object";
565
+ readonly type: 'object';
566
566
  readonly properties: {
567
567
  readonly event: {
568
- readonly type: "string";
569
- readonly enum: readonly ["runtime", "manual"];
568
+ readonly type: 'string';
569
+ readonly enum: readonly ['runtime', 'manual'];
570
570
  };
571
571
  };
572
- readonly required: readonly ["event"];
572
+ readonly required: readonly ['event'];
573
573
  readonly additionalProperties: false;
574
574
  }, {
575
- readonly type: "array";
575
+ readonly type: 'array';
576
576
  readonly items: {
577
- readonly type: "object";
577
+ readonly type: 'object';
578
578
  readonly properties: {
579
579
  readonly event: {
580
- readonly type: "string";
581
- readonly enum: readonly ["runtime", "manual"];
580
+ readonly type: 'string';
581
+ readonly enum: readonly ['runtime', 'manual'];
582
582
  };
583
583
  };
584
- readonly required: readonly ["event"];
584
+ readonly required: readonly ['event'];
585
585
  readonly additionalProperties: false;
586
586
  };
587
587
  }];
588
588
  };
589
589
  };
590
- readonly required: readonly ["name", "key", "entities", "levels"];
590
+ readonly required: readonly ['name', 'key', 'entities', 'levels'];
591
591
  readonly additionalProperties: false;
592
592
  };
593
593
  export declare const scorecardsConfigSchema: {
594
- readonly type: "array";
594
+ readonly type: 'array';
595
595
  readonly items: {
596
- readonly type: "object";
596
+ readonly type: 'object';
597
597
  readonly properties: {
598
598
  readonly name: {
599
- readonly type: "string";
599
+ readonly type: 'string';
600
600
  };
601
601
  readonly key: {
602
- readonly type: "string";
602
+ readonly type: 'string';
603
603
  };
604
604
  readonly description: {
605
- readonly type: "string";
605
+ readonly type: 'string';
606
606
  };
607
607
  readonly entities: {
608
608
  readonly oneOf: readonly [{
609
- readonly type: "array";
609
+ readonly type: 'array';
610
610
  readonly items: {
611
611
  readonly oneOf: readonly [{
612
- readonly type: "object";
612
+ readonly type: 'object';
613
613
  readonly properties: {
614
614
  readonly field: {
615
- readonly type: "string";
615
+ readonly type: 'string';
616
616
  };
617
617
  readonly operator: {
618
- readonly type: "string";
619
- readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
618
+ readonly type: 'string';
619
+ readonly enum: readonly ['eq', 'in', 'gt', 'gte', 'lt', 'lte', 'contains', 'startsWith', 'endsWith', 'exists', 'isEmpty', 'between', 'matches', 'some', 'every', 'none'];
620
620
  };
621
621
  readonly value: {
622
622
  readonly oneOf: readonly [{
623
- readonly type: "boolean";
623
+ readonly type: 'boolean';
624
624
  }, {
625
- readonly type: "string";
625
+ readonly type: 'string';
626
626
  }, {
627
- readonly type: "number";
627
+ readonly type: 'number';
628
628
  }];
629
629
  };
630
630
  readonly modifier: {
631
- readonly type: "string";
632
- readonly enum: readonly ["not"];
631
+ readonly type: 'string';
632
+ readonly enum: readonly ['not'];
633
633
  };
634
634
  readonly match: {
635
- readonly type: "array";
635
+ readonly type: 'array';
636
636
  readonly items: {
637
- readonly type: "object";
637
+ readonly type: 'object';
638
638
  readonly properties: {
639
639
  readonly field: {
640
- readonly type: "string";
640
+ readonly type: 'string';
641
641
  };
642
642
  readonly operator: {
643
- readonly type: "string";
644
- readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
643
+ readonly type: 'string';
644
+ readonly enum: readonly ['eq', 'in', 'gt', 'gte', 'lt', 'lte', 'contains', 'startsWith', 'endsWith', 'exists', 'isEmpty', 'between', 'matches', 'some', 'every', 'none'];
645
645
  };
646
646
  readonly value: {
647
647
  readonly oneOf: readonly [{
648
- readonly type: "boolean";
648
+ readonly type: 'boolean';
649
649
  }, {
650
- readonly type: "string";
650
+ readonly type: 'string';
651
651
  }, {
652
- readonly type: "number";
652
+ readonly type: 'number';
653
653
  }];
654
654
  };
655
655
  readonly modifier: {
656
- readonly type: "string";
657
- readonly enum: readonly ["not"];
656
+ readonly type: 'string';
657
+ readonly enum: readonly ['not'];
658
658
  };
659
659
  };
660
660
  };
661
661
  };
662
662
  };
663
663
  }, {
664
- readonly type: "object";
664
+ readonly type: 'object';
665
665
  readonly properties: {
666
666
  readonly operator: {
667
- readonly type: "string";
668
- readonly enum: readonly ["and", "or"];
667
+ readonly type: 'string';
668
+ readonly enum: readonly ['and', 'or'];
669
669
  };
670
670
  readonly conditions: {
671
- readonly type: "array";
671
+ readonly type: 'array';
672
672
  readonly items: {
673
673
  readonly oneOf: readonly [{
674
- readonly type: "object";
674
+ readonly type: 'object';
675
675
  readonly properties: {
676
676
  readonly field: {
677
- readonly type: "string";
677
+ readonly type: 'string';
678
678
  };
679
679
  readonly operator: {
680
- readonly type: "string";
681
- readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
680
+ readonly type: 'string';
681
+ readonly enum: readonly ['eq', 'in', 'gt', 'gte', 'lt', 'lte', 'contains', 'startsWith', 'endsWith', 'exists', 'isEmpty', 'between', 'matches', 'some', 'every', 'none'];
682
682
  };
683
683
  readonly value: {
684
684
  readonly oneOf: readonly [{
685
- readonly type: "boolean";
685
+ readonly type: 'boolean';
686
686
  }, {
687
- readonly type: "string";
687
+ readonly type: 'string';
688
688
  }, {
689
- readonly type: "number";
689
+ readonly type: 'number';
690
690
  }];
691
691
  };
692
692
  readonly modifier: {
693
- readonly type: "string";
694
- readonly enum: readonly ["not"];
693
+ readonly type: 'string';
694
+ readonly enum: readonly ['not'];
695
695
  };
696
696
  readonly match: {
697
- readonly type: "array";
697
+ readonly type: 'array';
698
698
  readonly items: {
699
- readonly type: "object";
699
+ readonly type: 'object';
700
700
  readonly properties: {
701
701
  readonly field: {
702
- readonly type: "string";
702
+ readonly type: 'string';
703
703
  };
704
704
  readonly operator: {
705
- readonly type: "string";
706
- readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
705
+ readonly type: 'string';
706
+ readonly enum: readonly ['eq', 'in', 'gt', 'gte', 'lt', 'lte', 'contains', 'startsWith', 'endsWith', 'exists', 'isEmpty', 'between', 'matches', 'some', 'every', 'none'];
707
707
  };
708
708
  readonly value: {
709
709
  readonly oneOf: readonly [{
710
- readonly type: "boolean";
710
+ readonly type: 'boolean';
711
711
  }, {
712
- readonly type: "string";
712
+ readonly type: 'string';
713
713
  }, {
714
- readonly type: "number";
714
+ readonly type: 'number';
715
715
  }];
716
716
  };
717
717
  readonly modifier: {
718
- readonly type: "string";
719
- readonly enum: readonly ["not"];
718
+ readonly type: 'string';
719
+ readonly enum: readonly ['not'];
720
720
  };
721
721
  };
722
722
  };
723
723
  };
724
724
  };
725
725
  }, {
726
- readonly type: "object";
726
+ readonly type: 'object';
727
727
  readonly properties: {
728
728
  readonly operator: {
729
- readonly type: "string";
730
- readonly enum: readonly ["and", "or"];
729
+ readonly type: 'string';
730
+ readonly enum: readonly ['and', 'or'];
731
731
  };
732
732
  readonly conditions: {
733
- readonly type: "array";
733
+ readonly type: 'array';
734
734
  readonly items: {
735
- readonly type: "object";
735
+ readonly type: 'object';
736
736
  readonly properties: {
737
737
  readonly field: {
738
- readonly type: "string";
738
+ readonly type: 'string';
739
739
  };
740
740
  readonly operator: {
741
- readonly type: "string";
742
- readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
741
+ readonly type: 'string';
742
+ readonly enum: readonly ['eq', 'in', 'gt', 'gte', 'lt', 'lte', 'contains', 'startsWith', 'endsWith', 'exists', 'isEmpty', 'between', 'matches', 'some', 'every', 'none'];
743
743
  };
744
744
  readonly value: {
745
745
  readonly oneOf: readonly [{
746
- readonly type: "boolean";
746
+ readonly type: 'boolean';
747
747
  }, {
748
- readonly type: "string";
748
+ readonly type: 'string';
749
749
  }, {
750
- readonly type: "number";
750
+ readonly type: 'number';
751
751
  }];
752
752
  };
753
753
  readonly modifier: {
754
- readonly type: "string";
755
- readonly enum: readonly ["not"];
754
+ readonly type: 'string';
755
+ readonly enum: readonly ['not'];
756
756
  };
757
757
  readonly match: {
758
- readonly type: "array";
758
+ readonly type: 'array';
759
759
  readonly items: {
760
- readonly type: "object";
760
+ readonly type: 'object';
761
761
  readonly properties: {
762
762
  readonly field: {
763
- readonly type: "string";
763
+ readonly type: 'string';
764
764
  };
765
765
  readonly operator: {
766
- readonly type: "string";
767
- readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
766
+ readonly type: 'string';
767
+ readonly enum: readonly ['eq', 'in', 'gt', 'gte', 'lt', 'lte', 'contains', 'startsWith', 'endsWith', 'exists', 'isEmpty', 'between', 'matches', 'some', 'every', 'none'];
768
768
  };
769
769
  readonly value: {
770
770
  readonly oneOf: readonly [{
771
- readonly type: "boolean";
771
+ readonly type: 'boolean';
772
772
  }, {
773
- readonly type: "string";
773
+ readonly type: 'string';
774
774
  }, {
775
- readonly type: "number";
775
+ readonly type: 'number';
776
776
  }];
777
777
  };
778
778
  readonly modifier: {
779
- readonly type: "string";
780
- readonly enum: readonly ["not"];
779
+ readonly type: 'string';
780
+ readonly enum: readonly ['not'];
781
781
  };
782
782
  };
783
783
  };
@@ -786,196 +786,196 @@ export declare const scorecardsConfigSchema: {
786
786
  };
787
787
  };
788
788
  };
789
- readonly required: readonly ["operator", "conditions"];
789
+ readonly required: readonly ['operator', 'conditions'];
790
790
  readonly additionalProperties: false;
791
791
  }];
792
792
  };
793
793
  };
794
794
  };
795
- readonly required: readonly ["operator", "conditions"];
795
+ readonly required: readonly ['operator', 'conditions'];
796
796
  readonly additionalProperties: false;
797
797
  }];
798
798
  };
799
799
  }, {
800
- readonly type: "object";
800
+ readonly type: 'object';
801
801
  readonly properties: {
802
802
  readonly operator: {
803
- readonly type: "string";
804
- readonly enum: readonly ["and", "or"];
803
+ readonly type: 'string';
804
+ readonly enum: readonly ['and', 'or'];
805
805
  };
806
806
  readonly conditions: {
807
- readonly type: "array";
807
+ readonly type: 'array';
808
808
  readonly items: {
809
809
  readonly oneOf: readonly [{
810
- readonly type: "object";
810
+ readonly type: 'object';
811
811
  readonly properties: {
812
812
  readonly field: {
813
- readonly type: "string";
813
+ readonly type: 'string';
814
814
  };
815
815
  readonly operator: {
816
- readonly type: "string";
817
- readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
816
+ readonly type: 'string';
817
+ readonly enum: readonly ['eq', 'in', 'gt', 'gte', 'lt', 'lte', 'contains', 'startsWith', 'endsWith', 'exists', 'isEmpty', 'between', 'matches', 'some', 'every', 'none'];
818
818
  };
819
819
  readonly value: {
820
820
  readonly oneOf: readonly [{
821
- readonly type: "boolean";
821
+ readonly type: 'boolean';
822
822
  }, {
823
- readonly type: "string";
823
+ readonly type: 'string';
824
824
  }, {
825
- readonly type: "number";
825
+ readonly type: 'number';
826
826
  }];
827
827
  };
828
828
  readonly modifier: {
829
- readonly type: "string";
830
- readonly enum: readonly ["not"];
829
+ readonly type: 'string';
830
+ readonly enum: readonly ['not'];
831
831
  };
832
832
  readonly match: {
833
- readonly type: "array";
833
+ readonly type: 'array';
834
834
  readonly items: {
835
- readonly type: "object";
835
+ readonly type: 'object';
836
836
  readonly properties: {
837
837
  readonly field: {
838
- readonly type: "string";
838
+ readonly type: 'string';
839
839
  };
840
840
  readonly operator: {
841
- readonly type: "string";
842
- readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
841
+ readonly type: 'string';
842
+ readonly enum: readonly ['eq', 'in', 'gt', 'gte', 'lt', 'lte', 'contains', 'startsWith', 'endsWith', 'exists', 'isEmpty', 'between', 'matches', 'some', 'every', 'none'];
843
843
  };
844
844
  readonly value: {
845
845
  readonly oneOf: readonly [{
846
- readonly type: "boolean";
846
+ readonly type: 'boolean';
847
847
  }, {
848
- readonly type: "string";
848
+ readonly type: 'string';
849
849
  }, {
850
- readonly type: "number";
850
+ readonly type: 'number';
851
851
  }];
852
852
  };
853
853
  readonly modifier: {
854
- readonly type: "string";
855
- readonly enum: readonly ["not"];
854
+ readonly type: 'string';
855
+ readonly enum: readonly ['not'];
856
856
  };
857
857
  };
858
858
  };
859
859
  };
860
860
  };
861
861
  }, {
862
- readonly type: "object";
862
+ readonly type: 'object';
863
863
  readonly properties: {
864
864
  readonly operator: {
865
- readonly type: "string";
866
- readonly enum: readonly ["and", "or"];
865
+ readonly type: 'string';
866
+ readonly enum: readonly ['and', 'or'];
867
867
  };
868
868
  readonly conditions: {
869
- readonly type: "array";
869
+ readonly type: 'array';
870
870
  readonly items: {
871
871
  readonly oneOf: readonly [{
872
- readonly type: "object";
872
+ readonly type: 'object';
873
873
  readonly properties: {
874
874
  readonly field: {
875
- readonly type: "string";
875
+ readonly type: 'string';
876
876
  };
877
877
  readonly operator: {
878
- readonly type: "string";
879
- readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
878
+ readonly type: 'string';
879
+ readonly enum: readonly ['eq', 'in', 'gt', 'gte', 'lt', 'lte', 'contains', 'startsWith', 'endsWith', 'exists', 'isEmpty', 'between', 'matches', 'some', 'every', 'none'];
880
880
  };
881
881
  readonly value: {
882
882
  readonly oneOf: readonly [{
883
- readonly type: "boolean";
883
+ readonly type: 'boolean';
884
884
  }, {
885
- readonly type: "string";
885
+ readonly type: 'string';
886
886
  }, {
887
- readonly type: "number";
887
+ readonly type: 'number';
888
888
  }];
889
889
  };
890
890
  readonly modifier: {
891
- readonly type: "string";
892
- readonly enum: readonly ["not"];
891
+ readonly type: 'string';
892
+ readonly enum: readonly ['not'];
893
893
  };
894
894
  readonly match: {
895
- readonly type: "array";
895
+ readonly type: 'array';
896
896
  readonly items: {
897
- readonly type: "object";
897
+ readonly type: 'object';
898
898
  readonly properties: {
899
899
  readonly field: {
900
- readonly type: "string";
900
+ readonly type: 'string';
901
901
  };
902
902
  readonly operator: {
903
- readonly type: "string";
904
- readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
903
+ readonly type: 'string';
904
+ readonly enum: readonly ['eq', 'in', 'gt', 'gte', 'lt', 'lte', 'contains', 'startsWith', 'endsWith', 'exists', 'isEmpty', 'between', 'matches', 'some', 'every', 'none'];
905
905
  };
906
906
  readonly value: {
907
907
  readonly oneOf: readonly [{
908
- readonly type: "boolean";
908
+ readonly type: 'boolean';
909
909
  }, {
910
- readonly type: "string";
910
+ readonly type: 'string';
911
911
  }, {
912
- readonly type: "number";
912
+ readonly type: 'number';
913
913
  }];
914
914
  };
915
915
  readonly modifier: {
916
- readonly type: "string";
917
- readonly enum: readonly ["not"];
916
+ readonly type: 'string';
917
+ readonly enum: readonly ['not'];
918
918
  };
919
919
  };
920
920
  };
921
921
  };
922
922
  };
923
923
  }, {
924
- readonly type: "object";
924
+ readonly type: 'object';
925
925
  readonly properties: {
926
926
  readonly operator: {
927
- readonly type: "string";
928
- readonly enum: readonly ["and", "or"];
927
+ readonly type: 'string';
928
+ readonly enum: readonly ['and', 'or'];
929
929
  };
930
930
  readonly conditions: {
931
- readonly type: "array";
931
+ readonly type: 'array';
932
932
  readonly items: {
933
- readonly type: "object";
933
+ readonly type: 'object';
934
934
  readonly properties: {
935
935
  readonly field: {
936
- readonly type: "string";
936
+ readonly type: 'string';
937
937
  };
938
938
  readonly operator: {
939
- readonly type: "string";
940
- readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
939
+ readonly type: 'string';
940
+ readonly enum: readonly ['eq', 'in', 'gt', 'gte', 'lt', 'lte', 'contains', 'startsWith', 'endsWith', 'exists', 'isEmpty', 'between', 'matches', 'some', 'every', 'none'];
941
941
  };
942
942
  readonly value: {
943
943
  readonly oneOf: readonly [{
944
- readonly type: "boolean";
944
+ readonly type: 'boolean';
945
945
  }, {
946
- readonly type: "string";
946
+ readonly type: 'string';
947
947
  }, {
948
- readonly type: "number";
948
+ readonly type: 'number';
949
949
  }];
950
950
  };
951
951
  readonly modifier: {
952
- readonly type: "string";
953
- readonly enum: readonly ["not"];
952
+ readonly type: 'string';
953
+ readonly enum: readonly ['not'];
954
954
  };
955
955
  readonly match: {
956
- readonly type: "array";
956
+ readonly type: 'array';
957
957
  readonly items: {
958
- readonly type: "object";
958
+ readonly type: 'object';
959
959
  readonly properties: {
960
960
  readonly field: {
961
- readonly type: "string";
961
+ readonly type: 'string';
962
962
  };
963
963
  readonly operator: {
964
- readonly type: "string";
965
- readonly enum: readonly ["eq", "in", "gt", "gte", "lt", "lte", "contains", "startsWith", "endsWith", "exists", "isEmpty", "between", "matches", "some", "every", "none"];
964
+ readonly type: 'string';
965
+ readonly enum: readonly ['eq', 'in', 'gt', 'gte', 'lt', 'lte', 'contains', 'startsWith', 'endsWith', 'exists', 'isEmpty', 'between', 'matches', 'some', 'every', 'none'];
966
966
  };
967
967
  readonly value: {
968
968
  readonly oneOf: readonly [{
969
- readonly type: "boolean";
969
+ readonly type: 'boolean';
970
970
  }, {
971
- readonly type: "string";
971
+ readonly type: 'string';
972
972
  }, {
973
- readonly type: "number";
973
+ readonly type: 'number';
974
974
  }];
975
975
  };
976
976
  readonly modifier: {
977
- readonly type: "string";
978
- readonly enum: readonly ["not"];
977
+ readonly type: 'string';
978
+ readonly enum: readonly ['not'];
979
979
  };
980
980
  };
981
981
  };
@@ -984,204 +984,204 @@ export declare const scorecardsConfigSchema: {
984
984
  };
985
985
  };
986
986
  };
987
- readonly required: readonly ["operator", "conditions"];
987
+ readonly required: readonly ['operator', 'conditions'];
988
988
  readonly additionalProperties: false;
989
989
  }];
990
990
  };
991
991
  };
992
992
  };
993
- readonly required: readonly ["operator", "conditions"];
993
+ readonly required: readonly ['operator', 'conditions'];
994
994
  readonly additionalProperties: false;
995
995
  }];
996
996
  };
997
997
  };
998
998
  };
999
- readonly required: readonly ["operator", "conditions"];
999
+ readonly required: readonly ['operator', 'conditions'];
1000
1000
  readonly additionalProperties: false;
1001
1001
  }];
1002
1002
  };
1003
1003
  readonly levels: {
1004
- readonly type: "array";
1004
+ readonly type: 'array';
1005
1005
  readonly items: {
1006
- readonly type: "object";
1006
+ readonly type: 'object';
1007
1007
  readonly properties: {
1008
1008
  readonly name: {
1009
- readonly type: "string";
1009
+ readonly type: 'string';
1010
1010
  };
1011
1011
  readonly extends: {
1012
1012
  readonly nodeTypeName: undefined;
1013
- readonly type: "array";
1013
+ readonly type: 'array';
1014
1014
  readonly items: {
1015
- readonly type: "string";
1015
+ readonly type: 'string';
1016
1016
  };
1017
- readonly description: "Use extends to inherit rules and their configurations from other rulesets.";
1018
- readonly documentationLink: "https://redocly.com/docs/cli/configuration/reference/extends";
1017
+ readonly description: 'Use extends to inherit rules and their configurations from other rulesets.';
1018
+ readonly documentationLink: 'https://redocly.com/docs/cli/configuration/reference/extends';
1019
1019
  };
1020
1020
  readonly rules: {
1021
- readonly type: "object";
1021
+ readonly type: 'object';
1022
1022
  readonly additionalProperties: {
1023
1023
  readonly oneOf: readonly [{
1024
- readonly type: "string";
1024
+ readonly type: 'string';
1025
1025
  }, {
1026
- readonly type: "object";
1026
+ readonly type: 'object';
1027
1027
  readonly properties: {
1028
1028
  readonly severity: {
1029
- readonly type: "string";
1030
- readonly enum: readonly ["error", "warn", "off"];
1029
+ readonly type: 'string';
1030
+ readonly enum: readonly ['error', 'warn', 'off'];
1031
1031
  };
1032
1032
  readonly weight: {
1033
- readonly type: "number";
1033
+ readonly type: 'number';
1034
1034
  readonly default: 1;
1035
1035
  };
1036
1036
  };
1037
1037
  readonly additionalProperties: true;
1038
1038
  }, {
1039
- readonly type: "object";
1039
+ readonly type: 'object';
1040
1040
  readonly properties: {
1041
1041
  readonly title: {
1042
- readonly type: "string";
1042
+ readonly type: 'string';
1043
1043
  };
1044
1044
  readonly subject: {
1045
- readonly type: "object";
1045
+ readonly type: 'object';
1046
1046
  readonly properties: {
1047
1047
  readonly type: {
1048
- readonly type: "string";
1049
- readonly enum: readonly ["Entity", "EntityMetadata", "EntityRelations", "EntityRelation"];
1048
+ readonly type: 'string';
1049
+ readonly enum: readonly ['Entity', 'EntityMetadata', 'EntityRelations', 'EntityRelation'];
1050
1050
  };
1051
1051
  readonly property: {
1052
- readonly type: "string";
1052
+ readonly type: 'string';
1053
1053
  };
1054
1054
  };
1055
- readonly required: readonly ["type", "property"];
1055
+ readonly required: readonly ['type', 'property'];
1056
1056
  readonly additionalProperties: false;
1057
1057
  };
1058
1058
  readonly severity: {
1059
- readonly type: "string";
1060
- readonly enum: readonly ["error", "warn", "off"];
1059
+ readonly type: 'string';
1060
+ readonly enum: readonly ['error', 'warn', 'off'];
1061
1061
  };
1062
1062
  readonly message: {
1063
- readonly type: "string";
1063
+ readonly type: 'string';
1064
1064
  };
1065
1065
  readonly assertions: {
1066
- readonly type: "object";
1066
+ readonly type: 'object';
1067
1067
  readonly properties: {
1068
1068
  readonly defined: {
1069
- readonly type: "boolean";
1069
+ readonly type: 'boolean';
1070
1070
  };
1071
1071
  readonly nonEmpty: {
1072
- readonly type: "boolean";
1072
+ readonly type: 'boolean';
1073
1073
  };
1074
1074
  readonly eq: {};
1075
1075
  readonly gt: {
1076
- readonly type: "number";
1076
+ readonly type: 'number';
1077
1077
  };
1078
1078
  readonly gte: {
1079
- readonly type: "number";
1079
+ readonly type: 'number';
1080
1080
  };
1081
1081
  readonly lt: {
1082
- readonly type: "number";
1082
+ readonly type: 'number';
1083
1083
  };
1084
1084
  readonly lte: {
1085
- readonly type: "number";
1085
+ readonly type: 'number';
1086
1086
  };
1087
1087
  readonly const: {};
1088
1088
  };
1089
1089
  readonly additionalProperties: false;
1090
1090
  };
1091
1091
  readonly where: {
1092
- readonly type: "array";
1092
+ readonly type: 'array';
1093
1093
  readonly items: {
1094
- readonly type: "object";
1094
+ readonly type: 'object';
1095
1095
  readonly properties: {
1096
1096
  readonly subject: {
1097
- readonly type: "object";
1097
+ readonly type: 'object';
1098
1098
  readonly properties: {
1099
1099
  readonly type: {
1100
- readonly type: "string";
1101
- readonly enum: readonly ["Entity", "EntityMetadata", "EntityRelations", "EntityRelation"];
1100
+ readonly type: 'string';
1101
+ readonly enum: readonly ['Entity', 'EntityMetadata', 'EntityRelations', 'EntityRelation'];
1102
1102
  };
1103
1103
  readonly property: {
1104
- readonly type: "string";
1104
+ readonly type: 'string';
1105
1105
  };
1106
1106
  };
1107
- readonly required: readonly ["type", "property"];
1107
+ readonly required: readonly ['type', 'property'];
1108
1108
  readonly additionalProperties: false;
1109
1109
  };
1110
1110
  readonly assertions: {
1111
- readonly type: "object";
1111
+ readonly type: 'object';
1112
1112
  readonly properties: {
1113
1113
  readonly defined: {
1114
- readonly type: "boolean";
1114
+ readonly type: 'boolean';
1115
1115
  };
1116
1116
  readonly nonEmpty: {
1117
- readonly type: "boolean";
1117
+ readonly type: 'boolean';
1118
1118
  };
1119
1119
  readonly eq: {};
1120
1120
  readonly gt: {
1121
- readonly type: "number";
1121
+ readonly type: 'number';
1122
1122
  };
1123
1123
  readonly gte: {
1124
- readonly type: "number";
1124
+ readonly type: 'number';
1125
1125
  };
1126
1126
  readonly lt: {
1127
- readonly type: "number";
1127
+ readonly type: 'number';
1128
1128
  };
1129
1129
  readonly lte: {
1130
- readonly type: "number";
1130
+ readonly type: 'number';
1131
1131
  };
1132
1132
  readonly const: {};
1133
1133
  };
1134
1134
  readonly additionalProperties: false;
1135
1135
  };
1136
1136
  };
1137
- readonly required: readonly ["subject", "assertions"];
1137
+ readonly required: readonly ['subject', 'assertions'];
1138
1138
  readonly additionalProperties: false;
1139
1139
  };
1140
1140
  };
1141
1141
  readonly weight: {
1142
- readonly type: "number";
1142
+ readonly type: 'number';
1143
1143
  readonly default: 1;
1144
1144
  };
1145
1145
  };
1146
- readonly required: readonly ["subject", "assertions"];
1146
+ readonly required: readonly ['subject', 'assertions'];
1147
1147
  readonly additionalProperties: false;
1148
1148
  }];
1149
1149
  };
1150
1150
  };
1151
1151
  };
1152
- readonly required: readonly ["name"];
1152
+ readonly required: readonly ['name'];
1153
1153
  readonly additionalProperties: false;
1154
1154
  };
1155
1155
  readonly minItems: 1;
1156
1156
  };
1157
1157
  readonly trigger: {
1158
1158
  readonly oneOf: readonly [{
1159
- readonly type: "object";
1159
+ readonly type: 'object';
1160
1160
  readonly properties: {
1161
1161
  readonly event: {
1162
- readonly type: "string";
1163
- readonly enum: readonly ["runtime", "manual"];
1162
+ readonly type: 'string';
1163
+ readonly enum: readonly ['runtime', 'manual'];
1164
1164
  };
1165
1165
  };
1166
- readonly required: readonly ["event"];
1166
+ readonly required: readonly ['event'];
1167
1167
  readonly additionalProperties: false;
1168
1168
  }, {
1169
- readonly type: "array";
1169
+ readonly type: 'array';
1170
1170
  readonly items: {
1171
- readonly type: "object";
1171
+ readonly type: 'object';
1172
1172
  readonly properties: {
1173
1173
  readonly event: {
1174
- readonly type: "string";
1175
- readonly enum: readonly ["runtime", "manual"];
1174
+ readonly type: 'string';
1175
+ readonly enum: readonly ['runtime', 'manual'];
1176
1176
  };
1177
1177
  };
1178
- readonly required: readonly ["event"];
1178
+ readonly required: readonly ['event'];
1179
1179
  readonly additionalProperties: false;
1180
1180
  };
1181
1181
  }];
1182
1182
  };
1183
1183
  };
1184
- readonly required: readonly ["name", "key", "entities", "levels"];
1184
+ readonly required: readonly ['name', 'key', 'entities', 'levels'];
1185
1185
  readonly additionalProperties: false;
1186
1186
  };
1187
1187
  };