camstreamerlib 4.0.0-beta.83 → 4.0.0-beta.85

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (27) hide show
  1. package/cjs/CamStreamerAPI.d.ts +1 -266
  2. package/cjs/CamStreamerAPI.js +7 -4
  3. package/cjs/types/CamStreamerAPI/CamStreamerAPI.d.ts +1 -1842
  4. package/cjs/types/CamStreamerAPI/facebookSchema.d.ts +0 -103
  5. package/cjs/types/CamStreamerAPI/hlsSchema.d.ts +0 -103
  6. package/cjs/types/CamStreamerAPI/mpegDvbSchema.d.ts +0 -103
  7. package/cjs/types/CamStreamerAPI/oldStreamSchema.d.ts +24 -24
  8. package/cjs/types/CamStreamerAPI/rtmpSchema.d.ts +0 -103
  9. package/cjs/types/CamStreamerAPI/sdCardSchema.d.ts +0 -103
  10. package/cjs/types/CamStreamerAPI/streamCommonTypes.d.ts +0 -170
  11. package/cjs/types/CamStreamerAPI/streamCommonTypes.js +1 -20
  12. package/cjs/types/CamStreamerAPI/windySchema.d.ts +0 -103
  13. package/cjs/types/CamStreamerAPI/youtubeSchema.d.ts +0 -103
  14. package/esm/CamStreamerAPI.js +7 -4
  15. package/esm/types/CamStreamerAPI/streamCommonTypes.js +0 -19
  16. package/package.json +1 -1
  17. package/types/CamStreamerAPI.d.ts +1 -266
  18. package/types/types/CamStreamerAPI/CamStreamerAPI.d.ts +1 -1842
  19. package/types/types/CamStreamerAPI/facebookSchema.d.ts +0 -103
  20. package/types/types/CamStreamerAPI/hlsSchema.d.ts +0 -103
  21. package/types/types/CamStreamerAPI/mpegDvbSchema.d.ts +0 -103
  22. package/types/types/CamStreamerAPI/oldStreamSchema.d.ts +24 -24
  23. package/types/types/CamStreamerAPI/rtmpSchema.d.ts +0 -103
  24. package/types/types/CamStreamerAPI/sdCardSchema.d.ts +0 -103
  25. package/types/types/CamStreamerAPI/streamCommonTypes.d.ts +0 -170
  26. package/types/types/CamStreamerAPI/windySchema.d.ts +0 -103
  27. package/types/types/CamStreamerAPI/youtubeSchema.d.ts +0 -103
package/cjs/types/CamStreamerAPI/CamStreamerAPI.d.ts CHANGED
@@ -11,71 +11,6 @@ export declare const streamSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
11
11
  enabled: z.ZodBoolean;
12
12
  active: z.ZodBoolean;
13
13
  title: z.ZodString;
14
- trigger: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
15
- type: z.ZodLiteral<"manual">;
16
- }, "strip", z.ZodTypeAny, {
17
- type: "manual";
18
- }, {
19
- type: "manual";
20
- }>, z.ZodObject<{
21
- type: z.ZodLiteral<"onetime">;
22
- startTime: z.ZodNumber;
23
- stopTime: z.ZodNumber;
24
- }, "strip", z.ZodTypeAny, {
25
- type: "onetime";
26
- startTime: number;
27
- stopTime: number;
28
- }, {
29
- type: "onetime";
30
- startTime: number;
31
- stopTime: number;
32
- }>, z.ZodObject<{
33
- type: z.ZodLiteral<"recurrent">;
34
- schedule: z.ZodArray<z.ZodObject<{
35
- day: z.ZodNumber;
36
- startTimeS: z.ZodNumber;
37
- stopTimeS: z.ZodNumber;
38
- isActive: z.ZodBoolean;
39
- }, "strip", z.ZodTypeAny, {
40
- day: number;
41
- startTimeS: number;
42
- stopTimeS: number;
43
- isActive: boolean;
44
- }, {
45
- day: number;
46
- startTimeS: number;
47
- stopTimeS: number;
48
- isActive: boolean;
49
- }>, "many">;
50
- }, "strip", z.ZodTypeAny, {
51
- type: "recurrent";
52
- schedule: {
53
- day: number;
54
- startTimeS: number;
55
- stopTimeS: number;
56
- isActive: boolean;
57
- }[];
58
- }, {
59
- type: "recurrent";
60
- schedule: {
61
- day: number;
62
- startTimeS: number;
63
- stopTimeS: number;
64
- isActive: boolean;
65
- }[];
66
- }>, z.ZodObject<{
67
- type: z.ZodLiteral<"io">;
68
- ioPort: z.ZodString;
69
- triggerOn: z.ZodUnion<[z.ZodLiteral<"open">, z.ZodLiteral<"closed">]>;
70
- }, "strip", z.ZodTypeAny, {
71
- type: "io";
72
- ioPort: string;
73
- triggerOn: "open" | "closed";
74
- }, {
75
- type: "io";
76
- ioPort: string;
77
- triggerOn: "open" | "closed";
78
- }>]>;
79
14
  } & {
80
15
  type: z.ZodLiteral<"facebook">;
81
16
  }, "strip", z.ZodTypeAny, {
@@ -84,120 +19,17 @@ export declare const streamSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
84
19
  id: number;
85
20
  active: boolean;
86
21
  title: string;
87
- trigger: {
88
- type: "manual";
89
- } | {
90
- type: "onetime";
91
- startTime: number;
92
- stopTime: number;
93
- } | {
94
- type: "recurrent";
95
- schedule: {
96
- day: number;
97
- startTimeS: number;
98
- stopTimeS: number;
99
- isActive: boolean;
100
- }[];
101
- } | {
102
- type: "io";
103
- ioPort: string;
104
- triggerOn: "open" | "closed";
105
- };
106
22
  }, {
107
23
  type: "facebook";
108
24
  enabled: boolean;
109
25
  id: number;
110
26
  active: boolean;
111
27
  title: string;
112
- trigger: {
113
- type: "manual";
114
- } | {
115
- type: "onetime";
116
- startTime: number;
117
- stopTime: number;
118
- } | {
119
- type: "recurrent";
120
- schedule: {
121
- day: number;
122
- startTimeS: number;
123
- stopTimeS: number;
124
- isActive: boolean;
125
- }[];
126
- } | {
127
- type: "io";
128
- ioPort: string;
129
- triggerOn: "open" | "closed";
130
- };
131
28
  }>, z.ZodObject<{
132
29
  id: z.ZodNumber;
133
30
  enabled: z.ZodBoolean;
134
31
  active: z.ZodBoolean;
135
32
  title: z.ZodString;
136
- trigger: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
137
- type: z.ZodLiteral<"manual">;
138
- }, "strip", z.ZodTypeAny, {
139
- type: "manual";
140
- }, {
141
- type: "manual";
142
- }>, z.ZodObject<{
143
- type: z.ZodLiteral<"onetime">;
144
- startTime: z.ZodNumber;
145
- stopTime: z.ZodNumber;
146
- }, "strip", z.ZodTypeAny, {
147
- type: "onetime";
148
- startTime: number;
149
- stopTime: number;
150
- }, {
151
- type: "onetime";
152
- startTime: number;
153
- stopTime: number;
154
- }>, z.ZodObject<{
155
- type: z.ZodLiteral<"recurrent">;
156
- schedule: z.ZodArray<z.ZodObject<{
157
- day: z.ZodNumber;
158
- startTimeS: z.ZodNumber;
159
- stopTimeS: z.ZodNumber;
160
- isActive: z.ZodBoolean;
161
- }, "strip", z.ZodTypeAny, {
162
- day: number;
163
- startTimeS: number;
164
- stopTimeS: number;
165
- isActive: boolean;
166
- }, {
167
- day: number;
168
- startTimeS: number;
169
- stopTimeS: number;
170
- isActive: boolean;
171
- }>, "many">;
172
- }, "strip", z.ZodTypeAny, {
173
- type: "recurrent";
174
- schedule: {
175
- day: number;
176
- startTimeS: number;
177
- stopTimeS: number;
178
- isActive: boolean;
179
- }[];
180
- }, {
181
- type: "recurrent";
182
- schedule: {
183
- day: number;
184
- startTimeS: number;
185
- stopTimeS: number;
186
- isActive: boolean;
187
- }[];
188
- }>, z.ZodObject<{
189
- type: z.ZodLiteral<"io">;
190
- ioPort: z.ZodString;
191
- triggerOn: z.ZodUnion<[z.ZodLiteral<"open">, z.ZodLiteral<"closed">]>;
192
- }, "strip", z.ZodTypeAny, {
193
- type: "io";
194
- ioPort: string;
195
- triggerOn: "open" | "closed";
196
- }, {
197
- type: "io";
198
- ioPort: string;
199
- triggerOn: "open" | "closed";
200
- }>]>;
201
33
  } & {
202
34
  type: z.ZodLiteral<"hls">;
203
35
  }, "strip", z.ZodTypeAny, {
@@ -206,120 +38,17 @@ export declare const streamSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
206
38
  id: number;
207
39
  active: boolean;
208
40
  title: string;
209
- trigger: {
210
- type: "manual";
211
- } | {
212
- type: "onetime";
213
- startTime: number;
214
- stopTime: number;
215
- } | {
216
- type: "recurrent";
217
- schedule: {
218
- day: number;
219
- startTimeS: number;
220
- stopTimeS: number;
221
- isActive: boolean;
222
- }[];
223
- } | {
224
- type: "io";
225
- ioPort: string;
226
- triggerOn: "open" | "closed";
227
- };
228
41
  }, {
229
42
  type: "hls";
230
43
  enabled: boolean;
231
44
  id: number;
232
45
  active: boolean;
233
46
  title: string;
234
- trigger: {
235
- type: "manual";
236
- } | {
237
- type: "onetime";
238
- startTime: number;
239
- stopTime: number;
240
- } | {
241
- type: "recurrent";
242
- schedule: {
243
- day: number;
244
- startTimeS: number;
245
- stopTimeS: number;
246
- isActive: boolean;
247
- }[];
248
- } | {
249
- type: "io";
250
- ioPort: string;
251
- triggerOn: "open" | "closed";
252
- };
253
47
  }>, z.ZodObject<{
254
48
  id: z.ZodNumber;
255
49
  enabled: z.ZodBoolean;
256
50
  active: z.ZodBoolean;
257
51
  title: z.ZodString;
258
- trigger: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
259
- type: z.ZodLiteral<"manual">;
260
- }, "strip", z.ZodTypeAny, {
261
- type: "manual";
262
- }, {
263
- type: "manual";
264
- }>, z.ZodObject<{
265
- type: z.ZodLiteral<"onetime">;
266
- startTime: z.ZodNumber;
267
- stopTime: z.ZodNumber;
268
- }, "strip", z.ZodTypeAny, {
269
- type: "onetime";
270
- startTime: number;
271
- stopTime: number;
272
- }, {
273
- type: "onetime";
274
- startTime: number;
275
- stopTime: number;
276
- }>, z.ZodObject<{
277
- type: z.ZodLiteral<"recurrent">;
278
- schedule: z.ZodArray<z.ZodObject<{
279
- day: z.ZodNumber;
280
- startTimeS: z.ZodNumber;
281
- stopTimeS: z.ZodNumber;
282
- isActive: z.ZodBoolean;
283
- }, "strip", z.ZodTypeAny, {
284
- day: number;
285
- startTimeS: number;
286
- stopTimeS: number;
287
- isActive: boolean;
288
- }, {
289
- day: number;
290
- startTimeS: number;
291
- stopTimeS: number;
292
- isActive: boolean;
293
- }>, "many">;
294
- }, "strip", z.ZodTypeAny, {
295
- type: "recurrent";
296
- schedule: {
297
- day: number;
298
- startTimeS: number;
299
- stopTimeS: number;
300
- isActive: boolean;
301
- }[];
302
- }, {
303
- type: "recurrent";
304
- schedule: {
305
- day: number;
306
- startTimeS: number;
307
- stopTimeS: number;
308
- isActive: boolean;
309
- }[];
310
- }>, z.ZodObject<{
311
- type: z.ZodLiteral<"io">;
312
- ioPort: z.ZodString;
313
- triggerOn: z.ZodUnion<[z.ZodLiteral<"open">, z.ZodLiteral<"closed">]>;
314
- }, "strip", z.ZodTypeAny, {
315
- type: "io";
316
- ioPort: string;
317
- triggerOn: "open" | "closed";
318
- }, {
319
- type: "io";
320
- ioPort: string;
321
- triggerOn: "open" | "closed";
322
- }>]>;
323
52
  } & {
324
53
  type: z.ZodLiteral<"mpeg_dvb">;
325
54
  ipAddress: z.ZodString;
@@ -346,25 +75,6 @@ export declare const streamSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
346
75
  id: number;
347
76
  active: boolean;
348
77
  title: string;
349
- trigger: {
350
- type: "manual";
351
- } | {
352
- type: "onetime";
353
- startTime: number;
354
- stopTime: number;
355
- } | {
356
- type: "recurrent";
357
- schedule: {
358
- day: number;
359
- startTimeS: number;
360
- stopTimeS: number;
361
- isActive: boolean;
362
- }[];
363
- } | {
364
- type: "io";
365
- ioPort: string;
366
- triggerOn: "open" | "closed";
367
- };
368
78
  ipAddress: string;
369
79
  standard: "DVB" | "ATSC";
370
80
  nullPacketsPaddingEnabled: boolean;
@@ -388,25 +98,6 @@ export declare const streamSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
388
98
  id: number;
389
99
  active: boolean;
390
100
  title: string;
391
- trigger: {
392
- type: "manual";
393
- } | {
394
- type: "onetime";
395
- startTime: number;
396
- stopTime: number;
397
- } | {
398
- type: "recurrent";
399
- schedule: {
400
- day: number;
401
- startTimeS: number;
402
- stopTimeS: number;
403
- isActive: boolean;
404
- }[];
405
- } | {
406
- type: "io";
407
- ioPort: string;
408
- triggerOn: "open" | "closed";
409
- };
410
101
  ipAddress: string;
411
102
  standard: "DVB" | "ATSC";
412
103
  nullPacketsPaddingEnabled: boolean;
@@ -428,71 +119,6 @@ export declare const streamSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
428
119
  enabled: z.ZodBoolean;
429
120
  active: z.ZodBoolean;
430
121
  title: z.ZodString;
431
- trigger: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
432
- type: z.ZodLiteral<"manual">;
433
- }, "strip", z.ZodTypeAny, {
434
- type: "manual";
435
- }, {
436
- type: "manual";
437
- }>, z.ZodObject<{
438
- type: z.ZodLiteral<"onetime">;
439
- startTime: z.ZodNumber;
440
- stopTime: z.ZodNumber;
441
- }, "strip", z.ZodTypeAny, {
442
- type: "onetime";
443
- startTime: number;
444
- stopTime: number;
445
- }, {
446
- type: "onetime";
447
- startTime: number;
448
- stopTime: number;
449
- }>, z.ZodObject<{
450
- type: z.ZodLiteral<"recurrent">;
451
- schedule: z.ZodArray<z.ZodObject<{
452
- day: z.ZodNumber;
453
- startTimeS: z.ZodNumber;
454
- stopTimeS: z.ZodNumber;
455
- isActive: z.ZodBoolean;
456
- }, "strip", z.ZodTypeAny, {
457
- day: number;
458
- startTimeS: number;
459
- stopTimeS: number;
460
- isActive: boolean;
461
- }, {
462
- day: number;
463
- startTimeS: number;
464
- stopTimeS: number;
465
- isActive: boolean;
466
- }>, "many">;
467
- }, "strip", z.ZodTypeAny, {
468
- type: "recurrent";
469
- schedule: {
470
- day: number;
471
- startTimeS: number;
472
- stopTimeS: number;
473
- isActive: boolean;
474
- }[];
475
- }, {
476
- type: "recurrent";
477
- schedule: {
478
- day: number;
479
- startTimeS: number;
480
- stopTimeS: number;
481
- isActive: boolean;
482
- }[];
483
- }>, z.ZodObject<{
484
- type: z.ZodLiteral<"io">;
485
- ioPort: z.ZodString;
486
- triggerOn: z.ZodUnion<[z.ZodLiteral<"open">, z.ZodLiteral<"closed">]>;
487
- }, "strip", z.ZodTypeAny, {
488
- type: "io";
489
- ioPort: string;
490
- triggerOn: "open" | "closed";
491
- }, {
492
- type: "io";
493
- ioPort: string;
494
- triggerOn: "open" | "closed";
495
- }>]>;
496
122
  } & {
497
123
  type: z.ZodLiteral<"rtmp">;
498
124
  }, "strip", z.ZodTypeAny, {
@@ -501,120 +127,17 @@ export declare const streamSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
501
127
  id: number;
502
128
  active: boolean;
503
129
  title: string;
504
- trigger: {
505
- type: "manual";
506
- } | {
507
- type: "onetime";
508
- startTime: number;
509
- stopTime: number;
510
- } | {
511
- type: "recurrent";
512
- schedule: {
513
- day: number;
514
- startTimeS: number;
515
- stopTimeS: number;
516
- isActive: boolean;
517
- }[];
518
- } | {
519
- type: "io";
520
- ioPort: string;
521
- triggerOn: "open" | "closed";
522
- };
523
130
  }, {
524
131
  type: "rtmp";
525
132
  enabled: boolean;
526
133
  id: number;
527
134
  active: boolean;
528
135
  title: string;
529
- trigger: {
530
- type: "manual";
531
- } | {
532
- type: "onetime";
533
- startTime: number;
534
- stopTime: number;
535
- } | {
536
- type: "recurrent";
537
- schedule: {
538
- day: number;
539
- startTimeS: number;
540
- stopTimeS: number;
541
- isActive: boolean;
542
- }[];
543
- } | {
544
- type: "io";
545
- ioPort: string;
546
- triggerOn: "open" | "closed";
547
- };
548
136
  }>, z.ZodObject<{
549
137
  id: z.ZodNumber;
550
138
  enabled: z.ZodBoolean;
551
139
  active: z.ZodBoolean;
552
140
  title: z.ZodString;
553
- trigger: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
554
- type: z.ZodLiteral<"manual">;
555
- }, "strip", z.ZodTypeAny, {
556
- type: "manual";
557
- }, {
558
- type: "manual";
559
- }>, z.ZodObject<{
560
- type: z.ZodLiteral<"onetime">;
561
- startTime: z.ZodNumber;
562
- stopTime: z.ZodNumber;
563
- }, "strip", z.ZodTypeAny, {
564
- type: "onetime";
565
- startTime: number;
566
- stopTime: number;
567
- }, {
568
- type: "onetime";
569
- startTime: number;
570
- stopTime: number;
571
- }>, z.ZodObject<{
572
- type: z.ZodLiteral<"recurrent">;
573
- schedule: z.ZodArray<z.ZodObject<{
574
- day: z.ZodNumber;
575
- startTimeS: z.ZodNumber;
576
- stopTimeS: z.ZodNumber;
577
- isActive: z.ZodBoolean;
578
- }, "strip", z.ZodTypeAny, {
579
- day: number;
580
- startTimeS: number;
581
- stopTimeS: number;
582
- isActive: boolean;
583
- }, {
584
- day: number;
585
- startTimeS: number;
586
- stopTimeS: number;
587
- isActive: boolean;
588
- }>, "many">;
589
- }, "strip", z.ZodTypeAny, {
590
- type: "recurrent";
591
- schedule: {
592
- day: number;
593
- startTimeS: number;
594
- stopTimeS: number;
595
- isActive: boolean;
596
- }[];
597
- }, {
598
- type: "recurrent";
599
- schedule: {
600
- day: number;
601
- startTimeS: number;
602
- stopTimeS: number;
603
- isActive: boolean;
604
- }[];
605
- }>, z.ZodObject<{
606
- type: z.ZodLiteral<"io">;
607
- ioPort: z.ZodString;
608
- triggerOn: z.ZodUnion<[z.ZodLiteral<"open">, z.ZodLiteral<"closed">]>;
609
- }, "strip", z.ZodTypeAny, {
610
- type: "io";
611
- ioPort: string;
612
- triggerOn: "open" | "closed";
613
- }, {
614
- type: "io";
615
- ioPort: string;
616
- triggerOn: "open" | "closed";
617
- }>]>;
618
141
  } & {
619
142
  type: z.ZodLiteral<"sd_card">;
620
143
  }, "strip", z.ZodTypeAny, {
@@ -623,120 +146,17 @@ export declare const streamSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
623
146
  id: number;
624
147
  active: boolean;
625
148
  title: string;
626
- trigger: {
627
- type: "manual";
628
- } | {
629
- type: "onetime";
630
- startTime: number;
631
- stopTime: number;
632
- } | {
633
- type: "recurrent";
634
- schedule: {
635
- day: number;
636
- startTimeS: number;
637
- stopTimeS: number;
638
- isActive: boolean;
639
- }[];
640
- } | {
641
- type: "io";
642
- ioPort: string;
643
- triggerOn: "open" | "closed";
644
- };
645
149
  }, {
646
150
  type: "sd_card";
647
151
  enabled: boolean;
648
152
  id: number;
649
153
  active: boolean;
650
154
  title: string;
651
- trigger: {
652
- type: "manual";
653
- } | {
654
- type: "onetime";
655
- startTime: number;
656
- stopTime: number;
657
- } | {
658
- type: "recurrent";
659
- schedule: {
660
- day: number;
661
- startTimeS: number;
662
- stopTimeS: number;
663
- isActive: boolean;
664
- }[];
665
- } | {
666
- type: "io";
667
- ioPort: string;
668
- triggerOn: "open" | "closed";
669
- };
670
155
  }>, z.ZodObject<{
671
156
  id: z.ZodNumber;
672
157
  enabled: z.ZodBoolean;
673
158
  active: z.ZodBoolean;
674
159
  title: z.ZodString;
675
- trigger: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
676
- type: z.ZodLiteral<"manual">;
677
- }, "strip", z.ZodTypeAny, {
678
- type: "manual";
679
- }, {
680
- type: "manual";
681
- }>, z.ZodObject<{
682
- type: z.ZodLiteral<"onetime">;
683
- startTime: z.ZodNumber;
684
- stopTime: z.ZodNumber;
685
- }, "strip", z.ZodTypeAny, {
686
- type: "onetime";
687
- startTime: number;
688
- stopTime: number;
689
- }, {
690
- type: "onetime";
691
- startTime: number;
692
- stopTime: number;
693
- }>, z.ZodObject<{
694
- type: z.ZodLiteral<"recurrent">;
695
- schedule: z.ZodArray<z.ZodObject<{
696
- day: z.ZodNumber;
697
- startTimeS: z.ZodNumber;
698
- stopTimeS: z.ZodNumber;
699
- isActive: z.ZodBoolean;
700
- }, "strip", z.ZodTypeAny, {
701
- day: number;
702
- startTimeS: number;
703
- stopTimeS: number;
704
- isActive: boolean;
705
- }, {
706
- day: number;
707
- startTimeS: number;
708
- stopTimeS: number;
709
- isActive: boolean;
710
- }>, "many">;
711
- }, "strip", z.ZodTypeAny, {
712
- type: "recurrent";
713
- schedule: {
714
- day: number;
715
- startTimeS: number;
716
- stopTimeS: number;
717
- isActive: boolean;
718
- }[];
719
- }, {
720
- type: "recurrent";
721
- schedule: {
722
- day: number;
723
- startTimeS: number;
724
- stopTimeS: number;
725
- isActive: boolean;
726
- }[];
727
- }>, z.ZodObject<{
728
- type: z.ZodLiteral<"io">;
729
- ioPort: z.ZodString;
730
- triggerOn: z.ZodUnion<[z.ZodLiteral<"open">, z.ZodLiteral<"closed">]>;
731
- }, "strip", z.ZodTypeAny, {
732
- type: "io";
733
- ioPort: string;
734
- triggerOn: "open" | "closed";
735
- }, {
736
- type: "io";
737
- ioPort: string;
738
- triggerOn: "open" | "closed";
739
- }>]>;
740
160
  } & {
741
161
  type: z.ZodLiteral<"windy">;
742
162
  }, "strip", z.ZodTypeAny, {
@@ -745,120 +165,17 @@ export declare const streamSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
745
165
  id: number;
746
166
  active: boolean;
747
167
  title: string;
748
- trigger: {
749
- type: "manual";
750
- } | {
751
- type: "onetime";
752
- startTime: number;
753
- stopTime: number;
754
- } | {
755
- type: "recurrent";
756
- schedule: {
757
- day: number;
758
- startTimeS: number;
759
- stopTimeS: number;
760
- isActive: boolean;
761
- }[];
762
- } | {
763
- type: "io";
764
- ioPort: string;
765
- triggerOn: "open" | "closed";
766
- };
767
168
  }, {
768
169
  type: "windy";
769
170
  enabled: boolean;
770
171
  id: number;
771
172
  active: boolean;
772
173
  title: string;
773
- trigger: {
774
- type: "manual";
775
- } | {
776
- type: "onetime";
777
- startTime: number;
778
- stopTime: number;
779
- } | {
780
- type: "recurrent";
781
- schedule: {
782
- day: number;
783
- startTimeS: number;
784
- stopTimeS: number;
785
- isActive: boolean;
786
- }[];
787
- } | {
788
- type: "io";
789
- ioPort: string;
790
- triggerOn: "open" | "closed";
791
- };
792
174
  }>, z.ZodObject<{
793
175
  id: z.ZodNumber;
794
176
  enabled: z.ZodBoolean;
795
177
  active: z.ZodBoolean;
796
178
  title: z.ZodString;
797
- trigger: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
798
- type: z.ZodLiteral<"manual">;
799
- }, "strip", z.ZodTypeAny, {
800
- type: "manual";
801
- }, {
802
- type: "manual";
803
- }>, z.ZodObject<{
804
- type: z.ZodLiteral<"onetime">;
805
- startTime: z.ZodNumber;
806
- stopTime: z.ZodNumber;
807
- }, "strip", z.ZodTypeAny, {
808
- type: "onetime";
809
- startTime: number;
810
- stopTime: number;
811
- }, {
812
- type: "onetime";
813
- startTime: number;
814
- stopTime: number;
815
- }>, z.ZodObject<{
816
- type: z.ZodLiteral<"recurrent">;
817
- schedule: z.ZodArray<z.ZodObject<{
818
- day: z.ZodNumber;
819
- startTimeS: z.ZodNumber;
820
- stopTimeS: z.ZodNumber;
821
- isActive: z.ZodBoolean;
822
- }, "strip", z.ZodTypeAny, {
823
- day: number;
824
- startTimeS: number;
825
- stopTimeS: number;
826
- isActive: boolean;
827
- }, {
828
- day: number;
829
- startTimeS: number;
830
- stopTimeS: number;
831
- isActive: boolean;
832
- }>, "many">;
833
- }, "strip", z.ZodTypeAny, {
834
- type: "recurrent";
835
- schedule: {
836
- day: number;
837
- startTimeS: number;
838
- stopTimeS: number;
839
- isActive: boolean;
840
- }[];
841
- }, {
842
- type: "recurrent";
843
- schedule: {
844
- day: number;
845
- startTimeS: number;
846
- stopTimeS: number;
847
- isActive: boolean;
848
- }[];
849
- }>, z.ZodObject<{
850
- type: z.ZodLiteral<"io">;
851
- ioPort: z.ZodString;
852
- triggerOn: z.ZodUnion<[z.ZodLiteral<"open">, z.ZodLiteral<"closed">]>;
853
- }, "strip", z.ZodTypeAny, {
854
- type: "io";
855
- ioPort: string;
856
- triggerOn: "open" | "closed";
857
- }, {
858
- type: "io";
859
- ioPort: string;
860
- triggerOn: "open" | "closed";
861
- }>]>;
862
179
  } & {
863
180
  type: z.ZodLiteral<"youtube">;
864
181
  }, "strip", z.ZodTypeAny, {
@@ -867,50 +184,12 @@ export declare const streamSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
867
184
  id: number;
868
185
  active: boolean;
869
186
  title: string;
870
- trigger: {
871
- type: "manual";
872
- } | {
873
- type: "onetime";
874
- startTime: number;
875
- stopTime: number;
876
- } | {
877
- type: "recurrent";
878
- schedule: {
879
- day: number;
880
- startTimeS: number;
881
- stopTimeS: number;
882
- isActive: boolean;
883
- }[];
884
- } | {
885
- type: "io";
886
- ioPort: string;
887
- triggerOn: "open" | "closed";
888
- };
889
187
  }, {
890
188
  type: "youtube";
891
189
  enabled: boolean;
892
190
  id: number;
893
191
  active: boolean;
894
192
  title: string;
895
- trigger: {
896
- type: "manual";
897
- } | {
898
- type: "onetime";
899
- startTime: number;
900
- stopTime: number;
901
- } | {
902
- type: "recurrent";
903
- schedule: {
904
- day: number;
905
- startTimeS: number;
906
- stopTimeS: number;
907
- isActive: boolean;
908
- }[];
909
- } | {
910
- type: "io";
911
- ioPort: string;
912
- triggerOn: "open" | "closed";
913
- };
914
193
  }>]>;
915
194
  export type TStream = z.infer<typeof streamSchema>;
916
195
  export declare const streamListSchema: z.ZodObject<{
@@ -919,71 +198,6 @@ export declare const streamListSchema: z.ZodObject<{
919
198
  enabled: z.ZodBoolean;
920
199
  active: z.ZodBoolean;
921
200
  title: z.ZodString;
922
- trigger: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
923
- type: z.ZodLiteral<"manual">;
924
- }, "strip", z.ZodTypeAny, {
925
- type: "manual";
926
- }, {
927
- type: "manual";
928
- }>, z.ZodObject<{
929
- type: z.ZodLiteral<"onetime">;
930
- startTime: z.ZodNumber;
931
- stopTime: z.ZodNumber;
932
- }, "strip", z.ZodTypeAny, {
933
- type: "onetime";
934
- startTime: number;
935
- stopTime: number;
936
- }, {
937
- type: "onetime";
938
- startTime: number;
939
- stopTime: number;
940
- }>, z.ZodObject<{
941
- type: z.ZodLiteral<"recurrent">;
942
- schedule: z.ZodArray<z.ZodObject<{
943
- day: z.ZodNumber;
944
- startTimeS: z.ZodNumber;
945
- stopTimeS: z.ZodNumber;
946
- isActive: z.ZodBoolean;
947
- }, "strip", z.ZodTypeAny, {
948
- day: number;
949
- startTimeS: number;
950
- stopTimeS: number;
951
- isActive: boolean;
952
- }, {
953
- day: number;
954
- startTimeS: number;
955
- stopTimeS: number;
956
- isActive: boolean;
957
- }>, "many">;
958
- }, "strip", z.ZodTypeAny, {
959
- type: "recurrent";
960
- schedule: {
961
- day: number;
962
- startTimeS: number;
963
- stopTimeS: number;
964
- isActive: boolean;
965
- }[];
966
- }, {
967
- type: "recurrent";
968
- schedule: {
969
- day: number;
970
- startTimeS: number;
971
- stopTimeS: number;
972
- isActive: boolean;
973
- }[];
974
- }>, z.ZodObject<{
975
- type: z.ZodLiteral<"io">;
976
- ioPort: z.ZodString;
977
- triggerOn: z.ZodUnion<[z.ZodLiteral<"open">, z.ZodLiteral<"closed">]>;
978
- }, "strip", z.ZodTypeAny, {
979
- type: "io";
980
- ioPort: string;
981
- triggerOn: "open" | "closed";
982
- }, {
983
- type: "io";
984
- ioPort: string;
985
- triggerOn: "open" | "closed";
986
- }>]>;
987
201
  } & {
988
202
  type: z.ZodLiteral<"facebook">;
989
203
  }, "strip", z.ZodTypeAny, {
@@ -992,120 +206,17 @@ export declare const streamListSchema: z.ZodObject<{
992
206
  id: number;
993
207
  active: boolean;
994
208
  title: string;
995
- trigger: {
996
- type: "manual";
997
- } | {
998
- type: "onetime";
999
- startTime: number;
1000
- stopTime: number;
1001
- } | {
1002
- type: "recurrent";
1003
- schedule: {
1004
- day: number;
1005
- startTimeS: number;
1006
- stopTimeS: number;
1007
- isActive: boolean;
1008
- }[];
1009
- } | {
1010
- type: "io";
1011
- ioPort: string;
1012
- triggerOn: "open" | "closed";
1013
- };
1014
209
  }, {
1015
210
  type: "facebook";
1016
211
  enabled: boolean;
1017
212
  id: number;
1018
213
  active: boolean;
1019
214
  title: string;
1020
- trigger: {
1021
- type: "manual";
1022
- } | {
1023
- type: "onetime";
1024
- startTime: number;
1025
- stopTime: number;
1026
- } | {
1027
- type: "recurrent";
1028
- schedule: {
1029
- day: number;
1030
- startTimeS: number;
1031
- stopTimeS: number;
1032
- isActive: boolean;
1033
- }[];
1034
- } | {
1035
- type: "io";
1036
- ioPort: string;
1037
- triggerOn: "open" | "closed";
1038
- };
1039
215
  }>, z.ZodObject<{
1040
216
  id: z.ZodNumber;
1041
217
  enabled: z.ZodBoolean;
1042
218
  active: z.ZodBoolean;
1043
219
  title: z.ZodString;
1044
- trigger: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
1045
- type: z.ZodLiteral<"manual">;
1046
- }, "strip", z.ZodTypeAny, {
1047
- type: "manual";
1048
- }, {
1049
- type: "manual";
1050
- }>, z.ZodObject<{
1051
- type: z.ZodLiteral<"onetime">;
1052
- startTime: z.ZodNumber;
1053
- stopTime: z.ZodNumber;
1054
- }, "strip", z.ZodTypeAny, {
1055
- type: "onetime";
1056
- startTime: number;
1057
- stopTime: number;
1058
- }, {
1059
- type: "onetime";
1060
- startTime: number;
1061
- stopTime: number;
1062
- }>, z.ZodObject<{
1063
- type: z.ZodLiteral<"recurrent">;
1064
- schedule: z.ZodArray<z.ZodObject<{
1065
- day: z.ZodNumber;
1066
- startTimeS: z.ZodNumber;
1067
- stopTimeS: z.ZodNumber;
1068
- isActive: z.ZodBoolean;
1069
- }, "strip", z.ZodTypeAny, {
1070
- day: number;
1071
- startTimeS: number;
1072
- stopTimeS: number;
1073
- isActive: boolean;
1074
- }, {
1075
- day: number;
1076
- startTimeS: number;
1077
- stopTimeS: number;
1078
- isActive: boolean;
1079
- }>, "many">;
1080
- }, "strip", z.ZodTypeAny, {
1081
- type: "recurrent";
1082
- schedule: {
1083
- day: number;
1084
- startTimeS: number;
1085
- stopTimeS: number;
1086
- isActive: boolean;
1087
- }[];
1088
- }, {
1089
- type: "recurrent";
1090
- schedule: {
1091
- day: number;
1092
- startTimeS: number;
1093
- stopTimeS: number;
1094
- isActive: boolean;
1095
- }[];
1096
- }>, z.ZodObject<{
1097
- type: z.ZodLiteral<"io">;
1098
- ioPort: z.ZodString;
1099
- triggerOn: z.ZodUnion<[z.ZodLiteral<"open">, z.ZodLiteral<"closed">]>;
1100
- }, "strip", z.ZodTypeAny, {
1101
- type: "io";
1102
- ioPort: string;
1103
- triggerOn: "open" | "closed";
1104
- }, {
1105
- type: "io";
1106
- ioPort: string;
1107
- triggerOn: "open" | "closed";
1108
- }>]>;
1109
220
  } & {
1110
221
  type: z.ZodLiteral<"hls">;
1111
222
  }, "strip", z.ZodTypeAny, {
@@ -1114,120 +225,17 @@ export declare const streamListSchema: z.ZodObject<{
1114
225
  id: number;
1115
226
  active: boolean;
1116
227
  title: string;
1117
- trigger: {
1118
- type: "manual";
1119
- } | {
1120
- type: "onetime";
1121
- startTime: number;
1122
- stopTime: number;
1123
- } | {
1124
- type: "recurrent";
1125
- schedule: {
1126
- day: number;
1127
- startTimeS: number;
1128
- stopTimeS: number;
1129
- isActive: boolean;
1130
- }[];
1131
- } | {
1132
- type: "io";
1133
- ioPort: string;
1134
- triggerOn: "open" | "closed";
1135
- };
1136
228
  }, {
1137
229
  type: "hls";
1138
230
  enabled: boolean;
1139
231
  id: number;
1140
232
  active: boolean;
1141
233
  title: string;
1142
- trigger: {
1143
- type: "manual";
1144
- } | {
1145
- type: "onetime";
1146
- startTime: number;
1147
- stopTime: number;
1148
- } | {
1149
- type: "recurrent";
1150
- schedule: {
1151
- day: number;
1152
- startTimeS: number;
1153
- stopTimeS: number;
1154
- isActive: boolean;
1155
- }[];
1156
- } | {
1157
- type: "io";
1158
- ioPort: string;
1159
- triggerOn: "open" | "closed";
1160
- };
1161
234
  }>, z.ZodObject<{
1162
235
  id: z.ZodNumber;
1163
236
  enabled: z.ZodBoolean;
1164
237
  active: z.ZodBoolean;
1165
238
  title: z.ZodString;
1166
- trigger: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
1167
- type: z.ZodLiteral<"manual">;
1168
- }, "strip", z.ZodTypeAny, {
1169
- type: "manual";
1170
- }, {
1171
- type: "manual";
1172
- }>, z.ZodObject<{
1173
- type: z.ZodLiteral<"onetime">;
1174
- startTime: z.ZodNumber;
1175
- stopTime: z.ZodNumber;
1176
- }, "strip", z.ZodTypeAny, {
1177
- type: "onetime";
1178
- startTime: number;
1179
- stopTime: number;
1180
- }, {
1181
- type: "onetime";
1182
- startTime: number;
1183
- stopTime: number;
1184
- }>, z.ZodObject<{
1185
- type: z.ZodLiteral<"recurrent">;
1186
- schedule: z.ZodArray<z.ZodObject<{
1187
- day: z.ZodNumber;
1188
- startTimeS: z.ZodNumber;
1189
- stopTimeS: z.ZodNumber;
1190
- isActive: z.ZodBoolean;
1191
- }, "strip", z.ZodTypeAny, {
1192
- day: number;
1193
- startTimeS: number;
1194
- stopTimeS: number;
1195
- isActive: boolean;
1196
- }, {
1197
- day: number;
1198
- startTimeS: number;
1199
- stopTimeS: number;
1200
- isActive: boolean;
1201
- }>, "many">;
1202
- }, "strip", z.ZodTypeAny, {
1203
- type: "recurrent";
1204
- schedule: {
1205
- day: number;
1206
- startTimeS: number;
1207
- stopTimeS: number;
1208
- isActive: boolean;
1209
- }[];
1210
- }, {
1211
- type: "recurrent";
1212
- schedule: {
1213
- day: number;
1214
- startTimeS: number;
1215
- stopTimeS: number;
1216
- isActive: boolean;
1217
- }[];
1218
- }>, z.ZodObject<{
1219
- type: z.ZodLiteral<"io">;
1220
- ioPort: z.ZodString;
1221
- triggerOn: z.ZodUnion<[z.ZodLiteral<"open">, z.ZodLiteral<"closed">]>;
1222
- }, "strip", z.ZodTypeAny, {
1223
- type: "io";
1224
- ioPort: string;
1225
- triggerOn: "open" | "closed";
1226
- }, {
1227
- type: "io";
1228
- ioPort: string;
1229
- triggerOn: "open" | "closed";
1230
- }>]>;
1231
239
  } & {
1232
240
  type: z.ZodLiteral<"mpeg_dvb">;
1233
241
  ipAddress: z.ZodString;
@@ -1254,25 +262,6 @@ export declare const streamListSchema: z.ZodObject<{
1254
262
  id: number;
1255
263
  active: boolean;
1256
264
  title: string;
1257
- trigger: {
1258
- type: "manual";
1259
- } | {
1260
- type: "onetime";
1261
- startTime: number;
1262
- stopTime: number;
1263
- } | {
1264
- type: "recurrent";
1265
- schedule: {
1266
- day: number;
1267
- startTimeS: number;
1268
- stopTimeS: number;
1269
- isActive: boolean;
1270
- }[];
1271
- } | {
1272
- type: "io";
1273
- ioPort: string;
1274
- triggerOn: "open" | "closed";
1275
- };
1276
265
  ipAddress: string;
1277
266
  standard: "DVB" | "ATSC";
1278
267
  nullPacketsPaddingEnabled: boolean;
@@ -1296,25 +285,6 @@ export declare const streamListSchema: z.ZodObject<{
1296
285
  id: number;
1297
286
  active: boolean;
1298
287
  title: string;
1299
- trigger: {
1300
- type: "manual";
1301
- } | {
1302
- type: "onetime";
1303
- startTime: number;
1304
- stopTime: number;
1305
- } | {
1306
- type: "recurrent";
1307
- schedule: {
1308
- day: number;
1309
- startTimeS: number;
1310
- stopTimeS: number;
1311
- isActive: boolean;
1312
- }[];
1313
- } | {
1314
- type: "io";
1315
- ioPort: string;
1316
- triggerOn: "open" | "closed";
1317
- };
1318
288
  ipAddress: string;
1319
289
  standard: "DVB" | "ATSC";
1320
290
  nullPacketsPaddingEnabled: boolean;
@@ -1336,71 +306,6 @@ export declare const streamListSchema: z.ZodObject<{
1336
306
  enabled: z.ZodBoolean;
1337
307
  active: z.ZodBoolean;
1338
308
  title: z.ZodString;
1339
- trigger: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
1340
- type: z.ZodLiteral<"manual">;
1341
- }, "strip", z.ZodTypeAny, {
1342
- type: "manual";
1343
- }, {
1344
- type: "manual";
1345
- }>, z.ZodObject<{
1346
- type: z.ZodLiteral<"onetime">;
1347
- startTime: z.ZodNumber;
1348
- stopTime: z.ZodNumber;
1349
- }, "strip", z.ZodTypeAny, {
1350
- type: "onetime";
1351
- startTime: number;
1352
- stopTime: number;
1353
- }, {
1354
- type: "onetime";
1355
- startTime: number;
1356
- stopTime: number;
1357
- }>, z.ZodObject<{
1358
- type: z.ZodLiteral<"recurrent">;
1359
- schedule: z.ZodArray<z.ZodObject<{
1360
- day: z.ZodNumber;
1361
- startTimeS: z.ZodNumber;
1362
- stopTimeS: z.ZodNumber;
1363
- isActive: z.ZodBoolean;
1364
- }, "strip", z.ZodTypeAny, {
1365
- day: number;
1366
- startTimeS: number;
1367
- stopTimeS: number;
1368
- isActive: boolean;
1369
- }, {
1370
- day: number;
1371
- startTimeS: number;
1372
- stopTimeS: number;
1373
- isActive: boolean;
1374
- }>, "many">;
1375
- }, "strip", z.ZodTypeAny, {
1376
- type: "recurrent";
1377
- schedule: {
1378
- day: number;
1379
- startTimeS: number;
1380
- stopTimeS: number;
1381
- isActive: boolean;
1382
- }[];
1383
- }, {
1384
- type: "recurrent";
1385
- schedule: {
1386
- day: number;
1387
- startTimeS: number;
1388
- stopTimeS: number;
1389
- isActive: boolean;
1390
- }[];
1391
- }>, z.ZodObject<{
1392
- type: z.ZodLiteral<"io">;
1393
- ioPort: z.ZodString;
1394
- triggerOn: z.ZodUnion<[z.ZodLiteral<"open">, z.ZodLiteral<"closed">]>;
1395
- }, "strip", z.ZodTypeAny, {
1396
- type: "io";
1397
- ioPort: string;
1398
- triggerOn: "open" | "closed";
1399
- }, {
1400
- type: "io";
1401
- ioPort: string;
1402
- triggerOn: "open" | "closed";
1403
- }>]>;
1404
309
  } & {
1405
310
  type: z.ZodLiteral<"rtmp">;
1406
311
  }, "strip", z.ZodTypeAny, {
@@ -1409,120 +314,17 @@ export declare const streamListSchema: z.ZodObject<{
1409
314
  id: number;
1410
315
  active: boolean;
1411
316
  title: string;
1412
- trigger: {
1413
- type: "manual";
1414
- } | {
1415
- type: "onetime";
1416
- startTime: number;
1417
- stopTime: number;
1418
- } | {
1419
- type: "recurrent";
1420
- schedule: {
1421
- day: number;
1422
- startTimeS: number;
1423
- stopTimeS: number;
1424
- isActive: boolean;
1425
- }[];
1426
- } | {
1427
- type: "io";
1428
- ioPort: string;
1429
- triggerOn: "open" | "closed";
1430
- };
1431
317
  }, {
1432
318
  type: "rtmp";
1433
319
  enabled: boolean;
1434
320
  id: number;
1435
321
  active: boolean;
1436
322
  title: string;
1437
- trigger: {
1438
- type: "manual";
1439
- } | {
1440
- type: "onetime";
1441
- startTime: number;
1442
- stopTime: number;
1443
- } | {
1444
- type: "recurrent";
1445
- schedule: {
1446
- day: number;
1447
- startTimeS: number;
1448
- stopTimeS: number;
1449
- isActive: boolean;
1450
- }[];
1451
- } | {
1452
- type: "io";
1453
- ioPort: string;
1454
- triggerOn: "open" | "closed";
1455
- };
1456
323
  }>, z.ZodObject<{
1457
324
  id: z.ZodNumber;
1458
325
  enabled: z.ZodBoolean;
1459
326
  active: z.ZodBoolean;
1460
327
  title: z.ZodString;
1461
- trigger: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
1462
- type: z.ZodLiteral<"manual">;
1463
- }, "strip", z.ZodTypeAny, {
1464
- type: "manual";
1465
- }, {
1466
- type: "manual";
1467
- }>, z.ZodObject<{
1468
- type: z.ZodLiteral<"onetime">;
1469
- startTime: z.ZodNumber;
1470
- stopTime: z.ZodNumber;
1471
- }, "strip", z.ZodTypeAny, {
1472
- type: "onetime";
1473
- startTime: number;
1474
- stopTime: number;
1475
- }, {
1476
- type: "onetime";
1477
- startTime: number;
1478
- stopTime: number;
1479
- }>, z.ZodObject<{
1480
- type: z.ZodLiteral<"recurrent">;
1481
- schedule: z.ZodArray<z.ZodObject<{
1482
- day: z.ZodNumber;
1483
- startTimeS: z.ZodNumber;
1484
- stopTimeS: z.ZodNumber;
1485
- isActive: z.ZodBoolean;
1486
- }, "strip", z.ZodTypeAny, {
1487
- day: number;
1488
- startTimeS: number;
1489
- stopTimeS: number;
1490
- isActive: boolean;
1491
- }, {
1492
- day: number;
1493
- startTimeS: number;
1494
- stopTimeS: number;
1495
- isActive: boolean;
1496
- }>, "many">;
1497
- }, "strip", z.ZodTypeAny, {
1498
- type: "recurrent";
1499
- schedule: {
1500
- day: number;
1501
- startTimeS: number;
1502
- stopTimeS: number;
1503
- isActive: boolean;
1504
- }[];
1505
- }, {
1506
- type: "recurrent";
1507
- schedule: {
1508
- day: number;
1509
- startTimeS: number;
1510
- stopTimeS: number;
1511
- isActive: boolean;
1512
- }[];
1513
- }>, z.ZodObject<{
1514
- type: z.ZodLiteral<"io">;
1515
- ioPort: z.ZodString;
1516
- triggerOn: z.ZodUnion<[z.ZodLiteral<"open">, z.ZodLiteral<"closed">]>;
1517
- }, "strip", z.ZodTypeAny, {
1518
- type: "io";
1519
- ioPort: string;
1520
- triggerOn: "open" | "closed";
1521
- }, {
1522
- type: "io";
1523
- ioPort: string;
1524
- triggerOn: "open" | "closed";
1525
- }>]>;
1526
328
  } & {
1527
329
  type: z.ZodLiteral<"sd_card">;
1528
330
  }, "strip", z.ZodTypeAny, {
@@ -1531,120 +333,17 @@ export declare const streamListSchema: z.ZodObject<{
1531
333
  id: number;
1532
334
  active: boolean;
1533
335
  title: string;
1534
- trigger: {
1535
- type: "manual";
1536
- } | {
1537
- type: "onetime";
1538
- startTime: number;
1539
- stopTime: number;
1540
- } | {
1541
- type: "recurrent";
1542
- schedule: {
1543
- day: number;
1544
- startTimeS: number;
1545
- stopTimeS: number;
1546
- isActive: boolean;
1547
- }[];
1548
- } | {
1549
- type: "io";
1550
- ioPort: string;
1551
- triggerOn: "open" | "closed";
1552
- };
1553
336
  }, {
1554
337
  type: "sd_card";
1555
338
  enabled: boolean;
1556
339
  id: number;
1557
340
  active: boolean;
1558
341
  title: string;
1559
- trigger: {
1560
- type: "manual";
1561
- } | {
1562
- type: "onetime";
1563
- startTime: number;
1564
- stopTime: number;
1565
- } | {
1566
- type: "recurrent";
1567
- schedule: {
1568
- day: number;
1569
- startTimeS: number;
1570
- stopTimeS: number;
1571
- isActive: boolean;
1572
- }[];
1573
- } | {
1574
- type: "io";
1575
- ioPort: string;
1576
- triggerOn: "open" | "closed";
1577
- };
1578
342
  }>, z.ZodObject<{
1579
343
  id: z.ZodNumber;
1580
344
  enabled: z.ZodBoolean;
1581
345
  active: z.ZodBoolean;
1582
346
  title: z.ZodString;
1583
- trigger: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
1584
- type: z.ZodLiteral<"manual">;
1585
- }, "strip", z.ZodTypeAny, {
1586
- type: "manual";
1587
- }, {
1588
- type: "manual";
1589
- }>, z.ZodObject<{
1590
- type: z.ZodLiteral<"onetime">;
1591
- startTime: z.ZodNumber;
1592
- stopTime: z.ZodNumber;
1593
- }, "strip", z.ZodTypeAny, {
1594
- type: "onetime";
1595
- startTime: number;
1596
- stopTime: number;
1597
- }, {
1598
- type: "onetime";
1599
- startTime: number;
1600
- stopTime: number;
1601
- }>, z.ZodObject<{
1602
- type: z.ZodLiteral<"recurrent">;
1603
- schedule: z.ZodArray<z.ZodObject<{
1604
- day: z.ZodNumber;
1605
- startTimeS: z.ZodNumber;
1606
- stopTimeS: z.ZodNumber;
1607
- isActive: z.ZodBoolean;
1608
- }, "strip", z.ZodTypeAny, {
1609
- day: number;
1610
- startTimeS: number;
1611
- stopTimeS: number;
1612
- isActive: boolean;
1613
- }, {
1614
- day: number;
1615
- startTimeS: number;
1616
- stopTimeS: number;
1617
- isActive: boolean;
1618
- }>, "many">;
1619
- }, "strip", z.ZodTypeAny, {
1620
- type: "recurrent";
1621
- schedule: {
1622
- day: number;
1623
- startTimeS: number;
1624
- stopTimeS: number;
1625
- isActive: boolean;
1626
- }[];
1627
- }, {
1628
- type: "recurrent";
1629
- schedule: {
1630
- day: number;
1631
- startTimeS: number;
1632
- stopTimeS: number;
1633
- isActive: boolean;
1634
- }[];
1635
- }>, z.ZodObject<{
1636
- type: z.ZodLiteral<"io">;
1637
- ioPort: z.ZodString;
1638
- triggerOn: z.ZodUnion<[z.ZodLiteral<"open">, z.ZodLiteral<"closed">]>;
1639
- }, "strip", z.ZodTypeAny, {
1640
- type: "io";
1641
- ioPort: string;
1642
- triggerOn: "open" | "closed";
1643
- }, {
1644
- type: "io";
1645
- ioPort: string;
1646
- triggerOn: "open" | "closed";
1647
- }>]>;
1648
347
  } & {
1649
348
  type: z.ZodLiteral<"windy">;
1650
349
  }, "strip", z.ZodTypeAny, {
@@ -1653,120 +352,17 @@ export declare const streamListSchema: z.ZodObject<{
1653
352
  id: number;
1654
353
  active: boolean;
1655
354
  title: string;
1656
- trigger: {
1657
- type: "manual";
1658
- } | {
1659
- type: "onetime";
1660
- startTime: number;
1661
- stopTime: number;
1662
- } | {
1663
- type: "recurrent";
1664
- schedule: {
1665
- day: number;
1666
- startTimeS: number;
1667
- stopTimeS: number;
1668
- isActive: boolean;
1669
- }[];
1670
- } | {
1671
- type: "io";
1672
- ioPort: string;
1673
- triggerOn: "open" | "closed";
1674
- };
1675
355
  }, {
1676
356
  type: "windy";
1677
357
  enabled: boolean;
1678
358
  id: number;
1679
359
  active: boolean;
1680
360
  title: string;
1681
- trigger: {
1682
- type: "manual";
1683
- } | {
1684
- type: "onetime";
1685
- startTime: number;
1686
- stopTime: number;
1687
- } | {
1688
- type: "recurrent";
1689
- schedule: {
1690
- day: number;
1691
- startTimeS: number;
1692
- stopTimeS: number;
1693
- isActive: boolean;
1694
- }[];
1695
- } | {
1696
- type: "io";
1697
- ioPort: string;
1698
- triggerOn: "open" | "closed";
1699
- };
1700
361
  }>, z.ZodObject<{
1701
362
  id: z.ZodNumber;
1702
363
  enabled: z.ZodBoolean;
1703
364
  active: z.ZodBoolean;
1704
365
  title: z.ZodString;
1705
- trigger: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
1706
- type: z.ZodLiteral<"manual">;
1707
- }, "strip", z.ZodTypeAny, {
1708
- type: "manual";
1709
- }, {
1710
- type: "manual";
1711
- }>, z.ZodObject<{
1712
- type: z.ZodLiteral<"onetime">;
1713
- startTime: z.ZodNumber;
1714
- stopTime: z.ZodNumber;
1715
- }, "strip", z.ZodTypeAny, {
1716
- type: "onetime";
1717
- startTime: number;
1718
- stopTime: number;
1719
- }, {
1720
- type: "onetime";
1721
- startTime: number;
1722
- stopTime: number;
1723
- }>, z.ZodObject<{
1724
- type: z.ZodLiteral<"recurrent">;
1725
- schedule: z.ZodArray<z.ZodObject<{
1726
- day: z.ZodNumber;
1727
- startTimeS: z.ZodNumber;
1728
- stopTimeS: z.ZodNumber;
1729
- isActive: z.ZodBoolean;
1730
- }, "strip", z.ZodTypeAny, {
1731
- day: number;
1732
- startTimeS: number;
1733
- stopTimeS: number;
1734
- isActive: boolean;
1735
- }, {
1736
- day: number;
1737
- startTimeS: number;
1738
- stopTimeS: number;
1739
- isActive: boolean;
1740
- }>, "many">;
1741
- }, "strip", z.ZodTypeAny, {
1742
- type: "recurrent";
1743
- schedule: {
1744
- day: number;
1745
- startTimeS: number;
1746
- stopTimeS: number;
1747
- isActive: boolean;
1748
- }[];
1749
- }, {
1750
- type: "recurrent";
1751
- schedule: {
1752
- day: number;
1753
- startTimeS: number;
1754
- stopTimeS: number;
1755
- isActive: boolean;
1756
- }[];
1757
- }>, z.ZodObject<{
1758
- type: z.ZodLiteral<"io">;
1759
- ioPort: z.ZodString;
1760
- triggerOn: z.ZodUnion<[z.ZodLiteral<"open">, z.ZodLiteral<"closed">]>;
1761
- }, "strip", z.ZodTypeAny, {
1762
- type: "io";
1763
- ioPort: string;
1764
- triggerOn: "open" | "closed";
1765
- }, {
1766
- type: "io";
1767
- ioPort: string;
1768
- triggerOn: "open" | "closed";
1769
- }>]>;
1770
366
  } & {
1771
367
  type: z.ZodLiteral<"youtube">;
1772
368
  }, "strip", z.ZodTypeAny, {
@@ -1775,50 +371,12 @@ export declare const streamListSchema: z.ZodObject<{
1775
371
  id: number;
1776
372
  active: boolean;
1777
373
  title: string;
1778
- trigger: {
1779
- type: "manual";
1780
- } | {
1781
- type: "onetime";
1782
- startTime: number;
1783
- stopTime: number;
1784
- } | {
1785
- type: "recurrent";
1786
- schedule: {
1787
- day: number;
1788
- startTimeS: number;
1789
- stopTimeS: number;
1790
- isActive: boolean;
1791
- }[];
1792
- } | {
1793
- type: "io";
1794
- ioPort: string;
1795
- triggerOn: "open" | "closed";
1796
- };
1797
374
  }, {
1798
375
  type: "youtube";
1799
376
  enabled: boolean;
1800
377
  id: number;
1801
378
  active: boolean;
1802
379
  title: string;
1803
- trigger: {
1804
- type: "manual";
1805
- } | {
1806
- type: "onetime";
1807
- startTime: number;
1808
- stopTime: number;
1809
- } | {
1810
- type: "recurrent";
1811
- schedule: {
1812
- day: number;
1813
- startTimeS: number;
1814
- stopTimeS: number;
1815
- isActive: boolean;
1816
- }[];
1817
- } | {
1818
- type: "io";
1819
- ioPort: string;
1820
- triggerOn: "open" | "closed";
1821
- };
1822
380
  }>]>, "many">;
1823
381
  }, "strip", z.ZodTypeAny, {
1824
382
  streamList: ({
@@ -1827,50 +385,12 @@ export declare const streamListSchema: z.ZodObject<{
1827
385
  id: number;
1828
386
  active: boolean;
1829
387
  title: string;
1830
- trigger: {
1831
- type: "manual";
1832
- } | {
1833
- type: "onetime";
1834
- startTime: number;
1835
- stopTime: number;
1836
- } | {
1837
- type: "recurrent";
1838
- schedule: {
1839
- day: number;
1840
- startTimeS: number;
1841
- stopTimeS: number;
1842
- isActive: boolean;
1843
- }[];
1844
- } | {
1845
- type: "io";
1846
- ioPort: string;
1847
- triggerOn: "open" | "closed";
1848
- };
1849
388
  } | {
1850
389
  type: "hls";
1851
390
  enabled: boolean;
1852
391
  id: number;
1853
392
  active: boolean;
1854
393
  title: string;
1855
- trigger: {
1856
- type: "manual";
1857
- } | {
1858
- type: "onetime";
1859
- startTime: number;
1860
- stopTime: number;
1861
- } | {
1862
- type: "recurrent";
1863
- schedule: {
1864
- day: number;
1865
- startTimeS: number;
1866
- stopTimeS: number;
1867
- isActive: boolean;
1868
- }[];
1869
- } | {
1870
- type: "io";
1871
- ioPort: string;
1872
- triggerOn: "open" | "closed";
1873
- };
1874
394
  } | {
1875
395
  type: "mpeg_dvb";
1876
396
  port: number;
@@ -1878,25 +398,6 @@ export declare const streamListSchema: z.ZodObject<{
1878
398
  id: number;
1879
399
  active: boolean;
1880
400
  title: string;
1881
- trigger: {
1882
- type: "manual";
1883
- } | {
1884
- type: "onetime";
1885
- startTime: number;
1886
- stopTime: number;
1887
- } | {
1888
- type: "recurrent";
1889
- schedule: {
1890
- day: number;
1891
- startTimeS: number;
1892
- stopTimeS: number;
1893
- isActive: boolean;
1894
- }[];
1895
- } | {
1896
- type: "io";
1897
- ioPort: string;
1898
- triggerOn: "open" | "closed";
1899
- };
1900
401
  ipAddress: string;
1901
402
  standard: "DVB" | "ATSC";
1902
403
  nullPacketsPaddingEnabled: boolean;
@@ -1919,100 +420,24 @@ export declare const streamListSchema: z.ZodObject<{
1919
420
  id: number;
1920
421
  active: boolean;
1921
422
  title: string;
1922
- trigger: {
1923
- type: "manual";
1924
- } | {
1925
- type: "onetime";
1926
- startTime: number;
1927
- stopTime: number;
1928
- } | {
1929
- type: "recurrent";
1930
- schedule: {
1931
- day: number;
1932
- startTimeS: number;
1933
- stopTimeS: number;
1934
- isActive: boolean;
1935
- }[];
1936
- } | {
1937
- type: "io";
1938
- ioPort: string;
1939
- triggerOn: "open" | "closed";
1940
- };
1941
423
  } | {
1942
424
  type: "sd_card";
1943
425
  enabled: boolean;
1944
426
  id: number;
1945
427
  active: boolean;
1946
428
  title: string;
1947
- trigger: {
1948
- type: "manual";
1949
- } | {
1950
- type: "onetime";
1951
- startTime: number;
1952
- stopTime: number;
1953
- } | {
1954
- type: "recurrent";
1955
- schedule: {
1956
- day: number;
1957
- startTimeS: number;
1958
- stopTimeS: number;
1959
- isActive: boolean;
1960
- }[];
1961
- } | {
1962
- type: "io";
1963
- ioPort: string;
1964
- triggerOn: "open" | "closed";
1965
- };
1966
429
  } | {
1967
430
  type: "windy";
1968
431
  enabled: boolean;
1969
432
  id: number;
1970
433
  active: boolean;
1971
434
  title: string;
1972
- trigger: {
1973
- type: "manual";
1974
- } | {
1975
- type: "onetime";
1976
- startTime: number;
1977
- stopTime: number;
1978
- } | {
1979
- type: "recurrent";
1980
- schedule: {
1981
- day: number;
1982
- startTimeS: number;
1983
- stopTimeS: number;
1984
- isActive: boolean;
1985
- }[];
1986
- } | {
1987
- type: "io";
1988
- ioPort: string;
1989
- triggerOn: "open" | "closed";
1990
- };
1991
435
  } | {
1992
436
  type: "youtube";
1993
437
  enabled: boolean;
1994
438
  id: number;
1995
439
  active: boolean;
1996
440
  title: string;
1997
- trigger: {
1998
- type: "manual";
1999
- } | {
2000
- type: "onetime";
2001
- startTime: number;
2002
- stopTime: number;
2003
- } | {
2004
- type: "recurrent";
2005
- schedule: {
2006
- day: number;
2007
- startTimeS: number;
2008
- stopTimeS: number;
2009
- isActive: boolean;
2010
- }[];
2011
- } | {
2012
- type: "io";
2013
- ioPort: string;
2014
- triggerOn: "open" | "closed";
2015
- };
2016
441
  })[];
2017
442
  }, {
2018
443
  streamList: ({
@@ -2021,50 +446,12 @@ export declare const streamListSchema: z.ZodObject<{
2021
446
  id: number;
2022
447
  active: boolean;
2023
448
  title: string;
2024
- trigger: {
2025
- type: "manual";
2026
- } | {
2027
- type: "onetime";
2028
- startTime: number;
2029
- stopTime: number;
2030
- } | {
2031
- type: "recurrent";
2032
- schedule: {
2033
- day: number;
2034
- startTimeS: number;
2035
- stopTimeS: number;
2036
- isActive: boolean;
2037
- }[];
2038
- } | {
2039
- type: "io";
2040
- ioPort: string;
2041
- triggerOn: "open" | "closed";
2042
- };
2043
449
  } | {
2044
450
  type: "hls";
2045
451
  enabled: boolean;
2046
452
  id: number;
2047
453
  active: boolean;
2048
454
  title: string;
2049
- trigger: {
2050
- type: "manual";
2051
- } | {
2052
- type: "onetime";
2053
- startTime: number;
2054
- stopTime: number;
2055
- } | {
2056
- type: "recurrent";
2057
- schedule: {
2058
- day: number;
2059
- startTimeS: number;
2060
- stopTimeS: number;
2061
- isActive: boolean;
2062
- }[];
2063
- } | {
2064
- type: "io";
2065
- ioPort: string;
2066
- triggerOn: "open" | "closed";
2067
- };
2068
455
  } | {
2069
456
  type: "mpeg_dvb";
2070
457
  port: number;
@@ -2072,25 +459,6 @@ export declare const streamListSchema: z.ZodObject<{
2072
459
  id: number;
2073
460
  active: boolean;
2074
461
  title: string;
2075
- trigger: {
2076
- type: "manual";
2077
- } | {
2078
- type: "onetime";
2079
- startTime: number;
2080
- stopTime: number;
2081
- } | {
2082
- type: "recurrent";
2083
- schedule: {
2084
- day: number;
2085
- startTimeS: number;
2086
- stopTimeS: number;
2087
- isActive: boolean;
2088
- }[];
2089
- } | {
2090
- type: "io";
2091
- ioPort: string;
2092
- triggerOn: "open" | "closed";
2093
- };
2094
462
  ipAddress: string;
2095
463
  standard: "DVB" | "ATSC";
2096
464
  nullPacketsPaddingEnabled: boolean;
@@ -2113,100 +481,24 @@ export declare const streamListSchema: z.ZodObject<{
2113
481
  id: number;
2114
482
  active: boolean;
2115
483
  title: string;
2116
- trigger: {
2117
- type: "manual";
2118
- } | {
2119
- type: "onetime";
2120
- startTime: number;
2121
- stopTime: number;
2122
- } | {
2123
- type: "recurrent";
2124
- schedule: {
2125
- day: number;
2126
- startTimeS: number;
2127
- stopTimeS: number;
2128
- isActive: boolean;
2129
- }[];
2130
- } | {
2131
- type: "io";
2132
- ioPort: string;
2133
- triggerOn: "open" | "closed";
2134
- };
2135
484
  } | {
2136
485
  type: "sd_card";
2137
486
  enabled: boolean;
2138
487
  id: number;
2139
488
  active: boolean;
2140
489
  title: string;
2141
- trigger: {
2142
- type: "manual";
2143
- } | {
2144
- type: "onetime";
2145
- startTime: number;
2146
- stopTime: number;
2147
- } | {
2148
- type: "recurrent";
2149
- schedule: {
2150
- day: number;
2151
- startTimeS: number;
2152
- stopTimeS: number;
2153
- isActive: boolean;
2154
- }[];
2155
- } | {
2156
- type: "io";
2157
- ioPort: string;
2158
- triggerOn: "open" | "closed";
2159
- };
2160
490
  } | {
2161
491
  type: "windy";
2162
492
  enabled: boolean;
2163
493
  id: number;
2164
494
  active: boolean;
2165
495
  title: string;
2166
- trigger: {
2167
- type: "manual";
2168
- } | {
2169
- type: "onetime";
2170
- startTime: number;
2171
- stopTime: number;
2172
- } | {
2173
- type: "recurrent";
2174
- schedule: {
2175
- day: number;
2176
- startTimeS: number;
2177
- stopTimeS: number;
2178
- isActive: boolean;
2179
- }[];
2180
- } | {
2181
- type: "io";
2182
- ioPort: string;
2183
- triggerOn: "open" | "closed";
2184
- };
2185
496
  } | {
2186
497
  type: "youtube";
2187
498
  enabled: boolean;
2188
499
  id: number;
2189
500
  active: boolean;
2190
501
  title: string;
2191
- trigger: {
2192
- type: "manual";
2193
- } | {
2194
- type: "onetime";
2195
- startTime: number;
2196
- stopTime: number;
2197
- } | {
2198
- type: "recurrent";
2199
- schedule: {
2200
- day: number;
2201
- startTimeS: number;
2202
- stopTimeS: number;
2203
- isActive: boolean;
2204
- }[];
2205
- } | {
2206
- type: "io";
2207
- ioPort: string;
2208
- triggerOn: "open" | "closed";
2209
- };
2210
502
  })[];
2211
503
  }>;
2212
504
  export type TStreamList = z.infer<typeof streamListSchema>;
@@ -2217,25 +509,6 @@ export declare const isFacebookStream: (stream: TStream) => stream is {
2217
509
  id: number;
2218
510
  active: boolean;
2219
511
  title: string;
2220
- trigger: {
2221
- type: "manual";
2222
- } | {
2223
- type: "onetime";
2224
- startTime: number;
2225
- stopTime: number;
2226
- } | {
2227
- type: "recurrent";
2228
- schedule: {
2229
- day: number;
2230
- startTimeS: number;
2231
- stopTimeS: number;
2232
- isActive: boolean;
2233
- }[];
2234
- } | {
2235
- type: "io";
2236
- ioPort: string;
2237
- triggerOn: "open" | "closed";
2238
- };
2239
512
  };
2240
513
  export type THlsStream = z.infer<typeof hlsSchema>;
2241
514
  export declare const isHlsStream: (stream: TStream) => stream is {
@@ -2244,25 +517,6 @@ export declare const isHlsStream: (stream: TStream) => stream is {
2244
517
  id: number;
2245
518
  active: boolean;
2246
519
  title: string;
2247
- trigger: {
2248
- type: "manual";
2249
- } | {
2250
- type: "onetime";
2251
- startTime: number;
2252
- stopTime: number;
2253
- } | {
2254
- type: "recurrent";
2255
- schedule: {
2256
- day: number;
2257
- startTimeS: number;
2258
- stopTimeS: number;
2259
- isActive: boolean;
2260
- }[];
2261
- } | {
2262
- type: "io";
2263
- ioPort: string;
2264
- triggerOn: "open" | "closed";
2265
- };
2266
520
  };
2267
521
  export type TMpegDvbStream = z.infer<typeof mpegDvbSchema>;
2268
522
  export declare const isMpegDvbStream: (stream: TStream) => stream is {
@@ -2272,25 +526,6 @@ export declare const isMpegDvbStream: (stream: TStream) => stream is {
2272
526
  id: number;
2273
527
  active: boolean;
2274
528
  title: string;
2275
- trigger: {
2276
- type: "manual";
2277
- } | {
2278
- type: "onetime";
2279
- startTime: number;
2280
- stopTime: number;
2281
- } | {
2282
- type: "recurrent";
2283
- schedule: {
2284
- day: number;
2285
- startTimeS: number;
2286
- stopTimeS: number;
2287
- isActive: boolean;
2288
- }[];
2289
- } | {
2290
- type: "io";
2291
- ioPort: string;
2292
- triggerOn: "open" | "closed";
2293
- };
2294
529
  ipAddress: string;
2295
530
  standard: "DVB" | "ATSC";
2296
531
  nullPacketsPaddingEnabled: boolean;
@@ -2315,25 +550,6 @@ export declare const isRtmpStream: (stream: TStream) => stream is {
2315
550
  id: number;
2316
551
  active: boolean;
2317
552
  title: string;
2318
- trigger: {
2319
- type: "manual";
2320
- } | {
2321
- type: "onetime";
2322
- startTime: number;
2323
- stopTime: number;
2324
- } | {
2325
- type: "recurrent";
2326
- schedule: {
2327
- day: number;
2328
- startTimeS: number;
2329
- stopTimeS: number;
2330
- isActive: boolean;
2331
- }[];
2332
- } | {
2333
- type: "io";
2334
- ioPort: string;
2335
- triggerOn: "open" | "closed";
2336
- };
2337
553
  };
2338
554
  export type TSdCardStream = z.infer<typeof sdCardSchema>;
2339
555
  export declare const isSdCardStream: (stream: TStream) => stream is {
@@ -2342,25 +558,6 @@ export declare const isSdCardStream: (stream: TStream) => stream is {
2342
558
  id: number;
2343
559
  active: boolean;
2344
560
  title: string;
2345
- trigger: {
2346
- type: "manual";
2347
- } | {
2348
- type: "onetime";
2349
- startTime: number;
2350
- stopTime: number;
2351
- } | {
2352
- type: "recurrent";
2353
- schedule: {
2354
- day: number;
2355
- startTimeS: number;
2356
- stopTimeS: number;
2357
- isActive: boolean;
2358
- }[];
2359
- } | {
2360
- type: "io";
2361
- ioPort: string;
2362
- triggerOn: "open" | "closed";
2363
- };
2364
561
  };
2365
562
  export type TWindyStream = z.infer<typeof windySchema>;
2366
563
  export declare const isWindyStream: (stream: TStream) => stream is {
@@ -2369,25 +566,6 @@ export declare const isWindyStream: (stream: TStream) => stream is {
2369
566
  id: number;
2370
567
  active: boolean;
2371
568
  title: string;
2372
- trigger: {
2373
- type: "manual";
2374
- } | {
2375
- type: "onetime";
2376
- startTime: number;
2377
- stopTime: number;
2378
- } | {
2379
- type: "recurrent";
2380
- schedule: {
2381
- day: number;
2382
- startTimeS: number;
2383
- stopTimeS: number;
2384
- isActive: boolean;
2385
- }[];
2386
- } | {
2387
- type: "io";
2388
- ioPort: string;
2389
- triggerOn: "open" | "closed";
2390
- };
2391
569
  };
2392
570
  export type TYouTubeStream = z.infer<typeof youtubeSchema>;
2393
571
  export declare const isYouTubeStream: (stream: TStream) => stream is {
@@ -2396,25 +574,6 @@ export declare const isYouTubeStream: (stream: TStream) => stream is {
2396
574
  id: number;
2397
575
  active: boolean;
2398
576
  title: string;
2399
- trigger: {
2400
- type: "manual";
2401
- } | {
2402
- type: "onetime";
2403
- startTime: number;
2404
- stopTime: number;
2405
- } | {
2406
- type: "recurrent";
2407
- schedule: {
2408
- day: number;
2409
- startTimeS: number;
2410
- stopTimeS: number;
2411
- isActive: boolean;
2412
- }[];
2413
- } | {
2414
- type: "io";
2415
- ioPort: string;
2416
- triggerOn: "open" | "closed";
2417
- };
2418
577
  };
2419
578
  export declare enum AudioType {
2420
579
  MP3 = 0,
@@ -2422,7 +581,7 @@ export declare enum AudioType {
2422
581
  }
2423
582
  export declare const audioFileStorageTypeSchema: z.ZodUnion<[z.ZodLiteral<"flash">, z.ZodLiteral<"SD0">, z.ZodLiteral<"url">]>;
2424
583
  export type TAudioFileStorageType = z.infer<typeof audioFileStorageTypeSchema>;
2425
- export type TLocalStorageType = 'local' | 'url';
584
+ export type TSourceType = 'local' | 'url';
2426
585
  export declare const storageListSchema: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
2427
586
  type: z.ZodLiteral<"flash">;
2428
587
  flash: z.ZodString;