@mokei/host-protocol 0.14.0 → 0.15.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 (16) hide show
  1. package/LICENSE +0 -0
  2. package/README.md +20 -1
  3. package/lib/flow-schemas.d.ts +764 -0
  4. package/lib/flow-schemas.d.ts.map +1 -0
  5. package/lib/flow-schemas.js +541 -0
  6. package/lib/index.d.ts +4672 -94
  7. package/lib/index.d.ts.map +1 -1
  8. package/lib/index.js +462 -7
  9. package/lib/monitor-schemas.d.ts +161 -0
  10. package/lib/monitor-schemas.d.ts.map +1 -0
  11. package/lib/monitor-schemas.js +207 -0
  12. package/lib/trace-schemas.d.ts +878 -0
  13. package/lib/trace-schemas.d.ts.map +1 -0
  14. package/lib/trace-schemas.js +269 -0
  15. package/package.json +6 -5
  16. package/CHANGELOG.md +0 -11
package/lib/trace-schemas.d.ts ADDED
@@ -0,0 +1,878 @@
1
+ import type { FromSchema } from '@sozai/schema';
2
+ export declare const traceSummarySchema: {
3
+ readonly definitions: {
4
+ readonly json: {
5
+ anyOf: ({
6
+ type: "string";
7
+ items?: undefined;
8
+ additionalProperties?: undefined;
9
+ } | {
10
+ type: "number";
11
+ items?: undefined;
12
+ additionalProperties?: undefined;
13
+ } | {
14
+ type: "boolean";
15
+ items?: undefined;
16
+ additionalProperties?: undefined;
17
+ } | {
18
+ type: "null";
19
+ items?: undefined;
20
+ additionalProperties?: undefined;
21
+ } | {
22
+ type: "array";
23
+ items: {
24
+ $ref: string;
25
+ };
26
+ additionalProperties?: undefined;
27
+ } | {
28
+ type: "object";
29
+ additionalProperties: {
30
+ $ref: string;
31
+ };
32
+ items?: undefined;
33
+ })[];
34
+ };
35
+ };
36
+ readonly type: "object";
37
+ readonly properties: {
38
+ readonly traceID: {
39
+ readonly type: "string";
40
+ };
41
+ readonly rootSpanID: {
42
+ readonly type: "string";
43
+ };
44
+ readonly activeSegmentSpanID: {
45
+ readonly type: "string";
46
+ };
47
+ readonly kind: {
48
+ readonly type: "string";
49
+ readonly enum: readonly ["context", "mcp", "flow", "step"];
50
+ };
51
+ readonly name: {
52
+ readonly type: "string";
53
+ };
54
+ readonly active: {
55
+ readonly type: "boolean";
56
+ };
57
+ readonly outcome: {
58
+ readonly type: readonly ["string", "null"];
59
+ readonly enum: readonly ["ok", "error", "interrupted", null];
60
+ };
61
+ readonly startTime: {
62
+ readonly type: "number";
63
+ };
64
+ readonly endTime: {
65
+ readonly type: "number";
66
+ };
67
+ readonly attributes: {
68
+ readonly type: "object";
69
+ readonly properties: {
70
+ readonly 'mokei.run.id': {
71
+ readonly type: "string";
72
+ };
73
+ readonly 'mokei.flow.id': {
74
+ readonly type: "string";
75
+ };
76
+ readonly 'mokei.context.id': {
77
+ readonly type: "string";
78
+ };
79
+ readonly label: {
80
+ readonly type: "string";
81
+ };
82
+ };
83
+ readonly additionalProperties: false;
84
+ };
85
+ readonly spanCount: {
86
+ readonly type: "integer";
87
+ };
88
+ readonly errorCount: {
89
+ readonly type: "integer";
90
+ };
91
+ readonly droppedCount: {
92
+ readonly type: "integer";
93
+ };
94
+ readonly revision: {
95
+ readonly type: "integer";
96
+ };
97
+ };
98
+ readonly required: readonly ["traceID", "rootSpanID", "kind", "name", "active", "outcome", "startTime", "attributes", "spanCount", "errorCount", "droppedCount", "revision"];
99
+ readonly additionalProperties: false;
100
+ };
101
+ export type TraceSummary = FromSchema<typeof traceSummarySchema>;
102
+ export declare const openSpanSchema: {
103
+ readonly definitions: {
104
+ readonly json: {
105
+ anyOf: ({
106
+ type: "string";
107
+ items?: undefined;
108
+ additionalProperties?: undefined;
109
+ } | {
110
+ type: "number";
111
+ items?: undefined;
112
+ additionalProperties?: undefined;
113
+ } | {
114
+ type: "boolean";
115
+ items?: undefined;
116
+ additionalProperties?: undefined;
117
+ } | {
118
+ type: "null";
119
+ items?: undefined;
120
+ additionalProperties?: undefined;
121
+ } | {
122
+ type: "array";
123
+ items: {
124
+ $ref: string;
125
+ };
126
+ additionalProperties?: undefined;
127
+ } | {
128
+ type: "object";
129
+ additionalProperties: {
130
+ $ref: string;
131
+ };
132
+ items?: undefined;
133
+ })[];
134
+ };
135
+ };
136
+ readonly type: "object";
137
+ readonly properties: {
138
+ readonly traceID: {
139
+ readonly type: "string";
140
+ };
141
+ readonly spanID: {
142
+ readonly type: "string";
143
+ };
144
+ readonly parentSpanID: {
145
+ readonly type: "string";
146
+ };
147
+ readonly name: {
148
+ readonly type: "string";
149
+ };
150
+ readonly kind: {
151
+ readonly type: "number";
152
+ };
153
+ readonly startTime: {
154
+ readonly type: "number";
155
+ };
156
+ readonly attributes: {
157
+ readonly type: "object";
158
+ readonly additionalProperties: {
159
+ $ref: string;
160
+ };
161
+ };
162
+ readonly links: {
163
+ readonly type: "array";
164
+ readonly items: {
165
+ readonly type: "object";
166
+ readonly properties: {
167
+ readonly traceID: {
168
+ readonly type: "string";
169
+ };
170
+ readonly spanID: {
171
+ readonly type: "string";
172
+ };
173
+ };
174
+ readonly required: readonly ["traceID", "spanID"];
175
+ readonly additionalProperties: false;
176
+ };
177
+ };
178
+ };
179
+ readonly required: readonly ["traceID", "spanID", "name", "kind", "startTime", "attributes", "links"];
180
+ readonly additionalProperties: false;
181
+ };
182
+ export type OpenSpan = FromSchema<typeof openSpanSchema>;
183
+ export declare const traceLogSchema: {
184
+ readonly properties: {
185
+ readonly logID: {
186
+ readonly type: "string";
187
+ };
188
+ readonly traceID: {
189
+ readonly type: "string";
190
+ };
191
+ readonly spanID: {
192
+ readonly type: "string";
193
+ };
194
+ readonly timestamp: {
195
+ readonly type: "number";
196
+ };
197
+ readonly level: {
198
+ readonly type: "string";
199
+ readonly enum: readonly ["trace", "debug", "info", "warning", "error", "fatal"];
200
+ };
201
+ readonly category: {
202
+ readonly type: "array";
203
+ readonly items: {
204
+ readonly type: "string";
205
+ };
206
+ };
207
+ readonly message: {
208
+ readonly type: "string";
209
+ };
210
+ readonly properties: {
211
+ readonly type: "object";
212
+ readonly additionalProperties: {
213
+ $ref: string;
214
+ };
215
+ };
216
+ };
217
+ readonly required: readonly ["traceID", "spanID", "timestamp", "level", "category", "message", "properties", "logID"];
218
+ readonly definitions: {
219
+ readonly json: {
220
+ anyOf: ({
221
+ type: "string";
222
+ items?: undefined;
223
+ additionalProperties?: undefined;
224
+ } | {
225
+ type: "number";
226
+ items?: undefined;
227
+ additionalProperties?: undefined;
228
+ } | {
229
+ type: "boolean";
230
+ items?: undefined;
231
+ additionalProperties?: undefined;
232
+ } | {
233
+ type: "null";
234
+ items?: undefined;
235
+ additionalProperties?: undefined;
236
+ } | {
237
+ type: "array";
238
+ items: {
239
+ $ref: string;
240
+ };
241
+ additionalProperties?: undefined;
242
+ } | {
243
+ type: "object";
244
+ additionalProperties: {
245
+ $ref: string;
246
+ };
247
+ items?: undefined;
248
+ })[];
249
+ };
250
+ };
251
+ readonly type: "object";
252
+ readonly additionalProperties: false;
253
+ };
254
+ export type TraceLog = FromSchema<typeof traceLogSchema>;
255
+ export declare const tracesListParamsSchema: {
256
+ readonly type: "object";
257
+ readonly properties: {
258
+ readonly kind: {
259
+ readonly type: "string";
260
+ readonly enum: readonly ["context", "mcp", "flow", "step"];
261
+ };
262
+ readonly active: {
263
+ readonly type: "boolean";
264
+ };
265
+ readonly outcome: {
266
+ readonly type: readonly ["string", "null"];
267
+ readonly enum: readonly ["ok", "error", "interrupted", null];
268
+ };
269
+ readonly name: {
270
+ readonly type: "string";
271
+ };
272
+ readonly since: {
273
+ readonly type: "number";
274
+ };
275
+ readonly until: {
276
+ readonly type: "number";
277
+ };
278
+ readonly limit: {
279
+ readonly type: "integer";
280
+ };
281
+ readonly cursor: {
282
+ readonly type: "string";
283
+ };
284
+ };
285
+ readonly required: readonly ["limit"];
286
+ readonly additionalProperties: false;
287
+ };
288
+ export type TracesListParams = FromSchema<typeof tracesListParamsSchema>;
289
+ export declare const tracesListResultSchema: {
290
+ readonly definitions: {
291
+ readonly json: {
292
+ anyOf: ({
293
+ type: "string";
294
+ items?: undefined;
295
+ additionalProperties?: undefined;
296
+ } | {
297
+ type: "number";
298
+ items?: undefined;
299
+ additionalProperties?: undefined;
300
+ } | {
301
+ type: "boolean";
302
+ items?: undefined;
303
+ additionalProperties?: undefined;
304
+ } | {
305
+ type: "null";
306
+ items?: undefined;
307
+ additionalProperties?: undefined;
308
+ } | {
309
+ type: "array";
310
+ items: {
311
+ $ref: string;
312
+ };
313
+ additionalProperties?: undefined;
314
+ } | {
315
+ type: "object";
316
+ additionalProperties: {
317
+ $ref: string;
318
+ };
319
+ items?: undefined;
320
+ })[];
321
+ };
322
+ };
323
+ readonly type: "object";
324
+ readonly properties: {
325
+ readonly traces: {
326
+ readonly type: "array";
327
+ readonly items: {
328
+ readonly definitions: {
329
+ readonly json: {
330
+ anyOf: ({
331
+ type: "string";
332
+ items?: undefined;
333
+ additionalProperties?: undefined;
334
+ } | {
335
+ type: "number";
336
+ items?: undefined;
337
+ additionalProperties?: undefined;
338
+ } | {
339
+ type: "boolean";
340
+ items?: undefined;
341
+ additionalProperties?: undefined;
342
+ } | {
343
+ type: "null";
344
+ items?: undefined;
345
+ additionalProperties?: undefined;
346
+ } | {
347
+ type: "array";
348
+ items: {
349
+ $ref: string;
350
+ };
351
+ additionalProperties?: undefined;
352
+ } | {
353
+ type: "object";
354
+ additionalProperties: {
355
+ $ref: string;
356
+ };
357
+ items?: undefined;
358
+ })[];
359
+ };
360
+ };
361
+ readonly type: "object";
362
+ readonly properties: {
363
+ readonly traceID: {
364
+ readonly type: "string";
365
+ };
366
+ readonly rootSpanID: {
367
+ readonly type: "string";
368
+ };
369
+ readonly activeSegmentSpanID: {
370
+ readonly type: "string";
371
+ };
372
+ readonly kind: {
373
+ readonly type: "string";
374
+ readonly enum: readonly ["context", "mcp", "flow", "step"];
375
+ };
376
+ readonly name: {
377
+ readonly type: "string";
378
+ };
379
+ readonly active: {
380
+ readonly type: "boolean";
381
+ };
382
+ readonly outcome: {
383
+ readonly type: readonly ["string", "null"];
384
+ readonly enum: readonly ["ok", "error", "interrupted", null];
385
+ };
386
+ readonly startTime: {
387
+ readonly type: "number";
388
+ };
389
+ readonly endTime: {
390
+ readonly type: "number";
391
+ };
392
+ readonly attributes: {
393
+ readonly type: "object";
394
+ readonly properties: {
395
+ readonly 'mokei.run.id': {
396
+ readonly type: "string";
397
+ };
398
+ readonly 'mokei.flow.id': {
399
+ readonly type: "string";
400
+ };
401
+ readonly 'mokei.context.id': {
402
+ readonly type: "string";
403
+ };
404
+ readonly label: {
405
+ readonly type: "string";
406
+ };
407
+ };
408
+ readonly additionalProperties: false;
409
+ };
410
+ readonly spanCount: {
411
+ readonly type: "integer";
412
+ };
413
+ readonly errorCount: {
414
+ readonly type: "integer";
415
+ };
416
+ readonly droppedCount: {
417
+ readonly type: "integer";
418
+ };
419
+ readonly revision: {
420
+ readonly type: "integer";
421
+ };
422
+ };
423
+ readonly required: readonly ["traceID", "rootSpanID", "kind", "name", "active", "outcome", "startTime", "attributes", "spanCount", "errorCount", "droppedCount", "revision"];
424
+ readonly additionalProperties: false;
425
+ };
426
+ };
427
+ readonly cursor: {
428
+ readonly type: "string";
429
+ };
430
+ };
431
+ readonly required: readonly ["traces"];
432
+ readonly additionalProperties: false;
433
+ };
434
+ export type TracesListResult = FromSchema<typeof tracesListResultSchema>;
435
+ export declare const tracesGetParamsSchema: {
436
+ readonly type: "object";
437
+ readonly properties: {
438
+ readonly traceID: {
439
+ readonly type: "string";
440
+ };
441
+ };
442
+ readonly required: readonly ["traceID"];
443
+ readonly additionalProperties: false;
444
+ };
445
+ export declare const tracesGetResultSchema: {
446
+ readonly definitions: {
447
+ readonly json: {
448
+ anyOf: ({
449
+ type: "string";
450
+ items?: undefined;
451
+ additionalProperties?: undefined;
452
+ } | {
453
+ type: "number";
454
+ items?: undefined;
455
+ additionalProperties?: undefined;
456
+ } | {
457
+ type: "boolean";
458
+ items?: undefined;
459
+ additionalProperties?: undefined;
460
+ } | {
461
+ type: "null";
462
+ items?: undefined;
463
+ additionalProperties?: undefined;
464
+ } | {
465
+ type: "array";
466
+ items: {
467
+ $ref: string;
468
+ };
469
+ additionalProperties?: undefined;
470
+ } | {
471
+ type: "object";
472
+ additionalProperties: {
473
+ $ref: string;
474
+ };
475
+ items?: undefined;
476
+ })[];
477
+ };
478
+ };
479
+ readonly type: "object";
480
+ readonly properties: {
481
+ readonly summary: {
482
+ readonly definitions: {
483
+ readonly json: {
484
+ anyOf: ({
485
+ type: "string";
486
+ items?: undefined;
487
+ additionalProperties?: undefined;
488
+ } | {
489
+ type: "number";
490
+ items?: undefined;
491
+ additionalProperties?: undefined;
492
+ } | {
493
+ type: "boolean";
494
+ items?: undefined;
495
+ additionalProperties?: undefined;
496
+ } | {
497
+ type: "null";
498
+ items?: undefined;
499
+ additionalProperties?: undefined;
500
+ } | {
501
+ type: "array";
502
+ items: {
503
+ $ref: string;
504
+ };
505
+ additionalProperties?: undefined;
506
+ } | {
507
+ type: "object";
508
+ additionalProperties: {
509
+ $ref: string;
510
+ };
511
+ items?: undefined;
512
+ })[];
513
+ };
514
+ };
515
+ readonly type: "object";
516
+ readonly properties: {
517
+ readonly traceID: {
518
+ readonly type: "string";
519
+ };
520
+ readonly rootSpanID: {
521
+ readonly type: "string";
522
+ };
523
+ readonly activeSegmentSpanID: {
524
+ readonly type: "string";
525
+ };
526
+ readonly kind: {
527
+ readonly type: "string";
528
+ readonly enum: readonly ["context", "mcp", "flow", "step"];
529
+ };
530
+ readonly name: {
531
+ readonly type: "string";
532
+ };
533
+ readonly active: {
534
+ readonly type: "boolean";
535
+ };
536
+ readonly outcome: {
537
+ readonly type: readonly ["string", "null"];
538
+ readonly enum: readonly ["ok", "error", "interrupted", null];
539
+ };
540
+ readonly startTime: {
541
+ readonly type: "number";
542
+ };
543
+ readonly endTime: {
544
+ readonly type: "number";
545
+ };
546
+ readonly attributes: {
547
+ readonly type: "object";
548
+ readonly properties: {
549
+ readonly 'mokei.run.id': {
550
+ readonly type: "string";
551
+ };
552
+ readonly 'mokei.flow.id': {
553
+ readonly type: "string";
554
+ };
555
+ readonly 'mokei.context.id': {
556
+ readonly type: "string";
557
+ };
558
+ readonly label: {
559
+ readonly type: "string";
560
+ };
561
+ };
562
+ readonly additionalProperties: false;
563
+ };
564
+ readonly spanCount: {
565
+ readonly type: "integer";
566
+ };
567
+ readonly errorCount: {
568
+ readonly type: "integer";
569
+ };
570
+ readonly droppedCount: {
571
+ readonly type: "integer";
572
+ };
573
+ readonly revision: {
574
+ readonly type: "integer";
575
+ };
576
+ };
577
+ readonly required: readonly ["traceID", "rootSpanID", "kind", "name", "active", "outcome", "startTime", "attributes", "spanCount", "errorCount", "droppedCount", "revision"];
578
+ readonly additionalProperties: false;
579
+ };
580
+ readonly spans: {
581
+ readonly type: "array";
582
+ readonly items: {
583
+ readonly anyOf: readonly [{
584
+ readonly definitions: {
585
+ readonly json: {
586
+ anyOf: ({
587
+ type: "string";
588
+ items?: undefined;
589
+ additionalProperties?: undefined;
590
+ } | {
591
+ type: "number";
592
+ items?: undefined;
593
+ additionalProperties?: undefined;
594
+ } | {
595
+ type: "boolean";
596
+ items?: undefined;
597
+ additionalProperties?: undefined;
598
+ } | {
599
+ type: "null";
600
+ items?: undefined;
601
+ additionalProperties?: undefined;
602
+ } | {
603
+ type: "array";
604
+ items: {
605
+ $ref: string;
606
+ };
607
+ additionalProperties?: undefined;
608
+ } | {
609
+ type: "object";
610
+ additionalProperties: {
611
+ $ref: string;
612
+ };
613
+ items?: undefined;
614
+ })[];
615
+ };
616
+ };
617
+ readonly type: "object";
618
+ readonly properties: {
619
+ readonly traceID: {
620
+ readonly type: "string";
621
+ };
622
+ readonly spanID: {
623
+ readonly type: "string";
624
+ };
625
+ readonly parentSpanID: {
626
+ readonly type: "string";
627
+ };
628
+ readonly name: {
629
+ readonly type: "string";
630
+ };
631
+ readonly kind: {
632
+ readonly type: "number";
633
+ };
634
+ readonly startTime: {
635
+ readonly type: "number";
636
+ };
637
+ readonly endTime: {
638
+ readonly type: "number";
639
+ };
640
+ readonly status: {
641
+ readonly type: "object";
642
+ readonly properties: {
643
+ readonly code: {
644
+ readonly type: "number";
645
+ };
646
+ readonly message: {
647
+ readonly type: "string";
648
+ };
649
+ };
650
+ readonly required: readonly ["code"];
651
+ readonly additionalProperties: false;
652
+ };
653
+ readonly attributes: {
654
+ readonly type: "object";
655
+ readonly additionalProperties: {
656
+ $ref: string;
657
+ };
658
+ };
659
+ readonly events: {
660
+ readonly type: "array";
661
+ readonly items: {
662
+ readonly type: "object";
663
+ readonly properties: {
664
+ readonly name: {
665
+ readonly type: "string";
666
+ };
667
+ readonly time: {
668
+ readonly type: "number";
669
+ };
670
+ readonly attributes: {
671
+ readonly type: "object";
672
+ readonly additionalProperties: {
673
+ $ref: string;
674
+ };
675
+ };
676
+ };
677
+ readonly required: readonly ["name", "time", "attributes"];
678
+ readonly additionalProperties: false;
679
+ };
680
+ };
681
+ readonly links: {
682
+ readonly type: "array";
683
+ readonly items: {
684
+ readonly type: "object";
685
+ readonly properties: {
686
+ readonly traceID: {
687
+ readonly type: "string";
688
+ };
689
+ readonly spanID: {
690
+ readonly type: "string";
691
+ };
692
+ };
693
+ readonly required: readonly ["traceID", "spanID"];
694
+ readonly additionalProperties: false;
695
+ };
696
+ };
697
+ };
698
+ readonly required: readonly ["traceID", "spanID", "name", "kind", "startTime", "endTime", "status", "attributes", "events", "links"];
699
+ readonly additionalProperties: false;
700
+ }, {
701
+ readonly definitions: {
702
+ readonly json: {
703
+ anyOf: ({
704
+ type: "string";
705
+ items?: undefined;
706
+ additionalProperties?: undefined;
707
+ } | {
708
+ type: "number";
709
+ items?: undefined;
710
+ additionalProperties?: undefined;
711
+ } | {
712
+ type: "boolean";
713
+ items?: undefined;
714
+ additionalProperties?: undefined;
715
+ } | {
716
+ type: "null";
717
+ items?: undefined;
718
+ additionalProperties?: undefined;
719
+ } | {
720
+ type: "array";
721
+ items: {
722
+ $ref: string;
723
+ };
724
+ additionalProperties?: undefined;
725
+ } | {
726
+ type: "object";
727
+ additionalProperties: {
728
+ $ref: string;
729
+ };
730
+ items?: undefined;
731
+ })[];
732
+ };
733
+ };
734
+ readonly type: "object";
735
+ readonly properties: {
736
+ readonly traceID: {
737
+ readonly type: "string";
738
+ };
739
+ readonly spanID: {
740
+ readonly type: "string";
741
+ };
742
+ readonly parentSpanID: {
743
+ readonly type: "string";
744
+ };
745
+ readonly name: {
746
+ readonly type: "string";
747
+ };
748
+ readonly kind: {
749
+ readonly type: "number";
750
+ };
751
+ readonly startTime: {
752
+ readonly type: "number";
753
+ };
754
+ readonly attributes: {
755
+ readonly type: "object";
756
+ readonly additionalProperties: {
757
+ $ref: string;
758
+ };
759
+ };
760
+ readonly links: {
761
+ readonly type: "array";
762
+ readonly items: {
763
+ readonly type: "object";
764
+ readonly properties: {
765
+ readonly traceID: {
766
+ readonly type: "string";
767
+ };
768
+ readonly spanID: {
769
+ readonly type: "string";
770
+ };
771
+ };
772
+ readonly required: readonly ["traceID", "spanID"];
773
+ readonly additionalProperties: false;
774
+ };
775
+ };
776
+ };
777
+ readonly required: readonly ["traceID", "spanID", "name", "kind", "startTime", "attributes", "links"];
778
+ readonly additionalProperties: false;
779
+ }];
780
+ };
781
+ };
782
+ readonly logs: {
783
+ readonly type: "array";
784
+ readonly items: {
785
+ readonly properties: {
786
+ readonly logID: {
787
+ readonly type: "string";
788
+ };
789
+ readonly traceID: {
790
+ readonly type: "string";
791
+ };
792
+ readonly spanID: {
793
+ readonly type: "string";
794
+ };
795
+ readonly timestamp: {
796
+ readonly type: "number";
797
+ };
798
+ readonly level: {
799
+ readonly type: "string";
800
+ readonly enum: readonly ["trace", "debug", "info", "warning", "error", "fatal"];
801
+ };
802
+ readonly category: {
803
+ readonly type: "array";
804
+ readonly items: {
805
+ readonly type: "string";
806
+ };
807
+ };
808
+ readonly message: {
809
+ readonly type: "string";
810
+ };
811
+ readonly properties: {
812
+ readonly type: "object";
813
+ readonly additionalProperties: {
814
+ $ref: string;
815
+ };
816
+ };
817
+ };
818
+ readonly required: readonly ["traceID", "spanID", "timestamp", "level", "category", "message", "properties", "logID"];
819
+ readonly definitions: {
820
+ readonly json: {
821
+ anyOf: ({
822
+ type: "string";
823
+ items?: undefined;
824
+ additionalProperties?: undefined;
825
+ } | {
826
+ type: "number";
827
+ items?: undefined;
828
+ additionalProperties?: undefined;
829
+ } | {
830
+ type: "boolean";
831
+ items?: undefined;
832
+ additionalProperties?: undefined;
833
+ } | {
834
+ type: "null";
835
+ items?: undefined;
836
+ additionalProperties?: undefined;
837
+ } | {
838
+ type: "array";
839
+ items: {
840
+ $ref: string;
841
+ };
842
+ additionalProperties?: undefined;
843
+ } | {
844
+ type: "object";
845
+ additionalProperties: {
846
+ $ref: string;
847
+ };
848
+ items?: undefined;
849
+ })[];
850
+ };
851
+ };
852
+ readonly type: "object";
853
+ readonly additionalProperties: false;
854
+ };
855
+ };
856
+ readonly logsTruncated: {
857
+ readonly type: "boolean";
858
+ };
859
+ };
860
+ readonly required: readonly ["summary", "spans", "logs", "logsTruncated"];
861
+ readonly additionalProperties: false;
862
+ };
863
+ export type TracesGetResult = FromSchema<typeof tracesGetResultSchema>;
864
+ export declare const tracingInfoSchema: {
865
+ readonly type: "object";
866
+ readonly properties: {
867
+ readonly lostSummaryCount: {
868
+ readonly type: "integer";
869
+ };
870
+ readonly droppedCount: {
871
+ readonly type: "integer";
872
+ };
873
+ };
874
+ readonly required: readonly ["lostSummaryCount", "droppedCount"];
875
+ readonly additionalProperties: false;
876
+ };
877
+ export type TracingInfo = FromSchema<typeof tracingInfoSchema>;
878
+ //# sourceMappingURL=trace-schemas.d.ts.map