camstreamerlib 5.0.0-5bbcf7f → 5.0.0-9647f54

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 (54) hide show
  1. package/README.md +18 -0
  2. package/cjs/CamOverlayAPI.d.ts +4 -19
  3. package/cjs/CamStreamerAPI.d.ts +2 -21
  4. package/cjs/CamSwitcherAPI.d.ts +2 -1
  5. package/cjs/CamSwitcherAPI.js +2 -0
  6. package/cjs/PlaneTrackerAPI.d.ts +13 -76
  7. package/cjs/VapixAPI.d.ts +5 -19
  8. package/cjs/VapixAPI.js +1 -1
  9. package/cjs/bin/CreatePackage.js +17 -7
  10. package/cjs/internal/transformers.d.ts +4 -4
  11. package/cjs/internal/utils.js +3 -3
  12. package/cjs/node/CamOverlayDrawingAPI.d.ts +0 -3
  13. package/cjs/node/CamOverlayPainter/Frame.d.ts +0 -1
  14. package/cjs/node/CamOverlayPainter/ResourceManager.d.ts +2 -2
  15. package/cjs/node/CamOverlayPainter/ResourceManager.js +17 -7
  16. package/cjs/node/CamScripterAPICameraEventsGenerator.d.ts +0 -1
  17. package/cjs/node/DefaultClient.d.ts +0 -2
  18. package/cjs/node/Digest.js +17 -7
  19. package/cjs/node/HttpRequestSender.d.ts +0 -2
  20. package/cjs/node/HttpRequestSender.test.js +17 -7
  21. package/cjs/node/HttpServer.d.ts +0 -2
  22. package/cjs/node/HttpServer.js +17 -7
  23. package/cjs/node/TimeZoneDaemon.js +1 -2
  24. package/cjs/node/VapixEvents.js +1 -1
  25. package/cjs/node/WsClient.js +1 -1
  26. package/cjs/types/CamOverlayAPI/CamOverlayAPI.d.ts +14 -456
  27. package/cjs/types/CamStreamerAPI/CamStreamerAPI.d.ts +20 -1818
  28. package/cjs/types/CamSwitcherAPI.d.ts +1 -0
  29. package/cjs/types/CamSwitcherAPI.js +1 -0
  30. package/cjs/web/WsClient.js +1 -1
  31. package/esm/CamSwitcherAPI.js +2 -0
  32. package/esm/VapixAPI.js +1 -1
  33. package/esm/node/TimeZoneDaemon.js +1 -2
  34. package/esm/node/VapixEvents.js +1 -1
  35. package/esm/node/WsClient.js +1 -1
  36. package/esm/types/CamSwitcherAPI.js +1 -0
  37. package/esm/web/WsClient.js +1 -1
  38. package/package.json +6 -7
  39. package/types/CamOverlayAPI.d.ts +4 -19
  40. package/types/CamStreamerAPI.d.ts +2 -21
  41. package/types/CamSwitcherAPI.d.ts +2 -1
  42. package/types/PlaneTrackerAPI.d.ts +13 -76
  43. package/types/VapixAPI.d.ts +5 -19
  44. package/types/internal/transformers.d.ts +4 -4
  45. package/types/node/CamOverlayDrawingAPI.d.ts +0 -3
  46. package/types/node/CamOverlayPainter/Frame.d.ts +0 -1
  47. package/types/node/CamOverlayPainter/ResourceManager.d.ts +2 -2
  48. package/types/node/CamScripterAPICameraEventsGenerator.d.ts +0 -1
  49. package/types/node/DefaultClient.d.ts +0 -2
  50. package/types/node/HttpRequestSender.d.ts +0 -2
  51. package/types/node/HttpServer.d.ts +0 -2
  52. package/types/types/CamOverlayAPI/CamOverlayAPI.d.ts +14 -456
  53. package/types/types/CamStreamerAPI/CamStreamerAPI.d.ts +20 -1818
  54. package/types/types/CamSwitcherAPI.d.ts +1 -0
@@ -3608,1843 +3608,45 @@ export declare const streamListSchema: z.ZodObject<{
3608
3608
  }, z.core.$strip>;
3609
3609
  export type TStreamList = z.infer<typeof streamListSchema>;
3610
3610
  export type TFacebookStream = z.infer<typeof facebookSchema>;
3611
- export declare const isFacebookStream: (stream: TStream) => stream is {
3612
- streamId: string;
3613
- enabled: boolean;
3614
- active: boolean;
3615
- title: string;
3616
- callApi: boolean;
3617
- trigger: {
3618
- type: "manual";
3619
- port?: number | undefined;
3620
- } | {
3621
- type: "onetime";
3622
- startTime: number;
3623
- stopTime: number;
3624
- everActivated: boolean;
3625
- prepareAheadS?: number | undefined;
3626
- } | {
3627
- type: "recurrent";
3628
- schedule: {
3629
- start: {
3630
- day: number;
3631
- timeS: number;
3632
- };
3633
- stop: {
3634
- day: number;
3635
- timeS: number;
3636
- };
3637
- isActive: boolean;
3638
- }[];
3639
- prepareAheadS?: number | undefined;
3640
- };
3641
- video: {
3642
- output: {
3643
- type: "video";
3644
- url: string | null;
3645
- parameters: string;
3646
- saveToSdCard?: {
3647
- ruleId: string;
3648
- configurationId: string;
3649
- } | undefined;
3650
- } | {
3651
- type: "images";
3652
- url: string | null;
3653
- imageIntervalS: number;
3654
- } | {
3655
- type: "none";
3656
- saveToSdCard: {
3657
- ruleId: string;
3658
- configurationId: string;
3659
- };
3660
- };
3661
- input: {
3662
- type: "RTSP_URL";
3663
- url: string;
3664
- internalVapixParameters: string;
3665
- } | {
3666
- type: "CSw";
3667
- internalVapixParameters: string;
3668
- } | {
3669
- type: "CRS";
3670
- internalVapixParameters: string;
3671
- userVapixParameters: string;
3672
- };
3673
- delayS?: number | undefined;
3674
- };
3675
- audio: {
3676
- source: "none";
3677
- } | {
3678
- source: "microphone";
3679
- audioChannelNbr: number;
3680
- forceStereo: boolean;
3681
- } | {
3682
- source: "file";
3683
- name: string;
3684
- path: string;
3685
- forceStereo: boolean;
3686
- loadAsNone?: boolean | undefined;
3687
- } | {
3688
- source: "url";
3689
- name: string;
3690
- url: string;
3691
- avSyncMsec: number;
3692
- forceStereo: boolean;
3693
- };
3694
- status: {
3695
- led: boolean;
3696
- port?: number | undefined;
3697
- };
3698
- platform: "facebook";
3699
- deleteAfterEnd: boolean;
3700
- countdown: boolean;
3701
- post: {
3702
- postLocation: "timeline";
3703
- streamPrivacy: "public" | "friends" | "only_me";
3704
- } | {
3705
- postLocation: "page";
3706
- page: string;
3707
- };
3708
- description?: string | undefined;
3709
- };
3611
+ export declare const isFacebookStream: (stream: TStream) => stream is TFacebookStream;
3710
3612
  export type TFacebookRtmpStream = z.infer<typeof facebookRtmpSchema>;
3711
- export declare const isFacebookRtmpStream: (stream: TStream) => stream is {
3712
- streamId: string;
3713
- enabled: boolean;
3714
- active: boolean;
3715
- title: string;
3716
- callApi: boolean;
3717
- trigger: {
3718
- type: "manual";
3719
- port?: number | undefined;
3720
- } | {
3721
- type: "onetime";
3722
- startTime: number;
3723
- stopTime: number;
3724
- everActivated: boolean;
3725
- prepareAheadS?: number | undefined;
3726
- } | {
3727
- type: "recurrent";
3728
- schedule: {
3729
- start: {
3730
- day: number;
3731
- timeS: number;
3732
- };
3733
- stop: {
3734
- day: number;
3735
- timeS: number;
3736
- };
3737
- isActive: boolean;
3738
- }[];
3739
- prepareAheadS?: number | undefined;
3740
- };
3741
- video: {
3742
- output: {
3743
- type: "video";
3744
- url: string | null;
3745
- parameters: string;
3746
- saveToSdCard?: {
3747
- ruleId: string;
3748
- configurationId: string;
3749
- } | undefined;
3750
- } | {
3751
- type: "images";
3752
- url: string | null;
3753
- imageIntervalS: number;
3754
- } | {
3755
- type: "none";
3756
- saveToSdCard: {
3757
- ruleId: string;
3758
- configurationId: string;
3759
- };
3760
- };
3761
- input: {
3762
- type: "RTSP_URL";
3763
- url: string;
3764
- internalVapixParameters: string;
3765
- } | {
3766
- type: "CSw";
3767
- internalVapixParameters: string;
3768
- } | {
3769
- type: "CRS";
3770
- internalVapixParameters: string;
3771
- userVapixParameters: string;
3772
- };
3773
- delayS?: number | undefined;
3774
- };
3775
- audio: {
3776
- source: "none";
3777
- } | {
3778
- source: "microphone";
3779
- audioChannelNbr: number;
3780
- forceStereo: boolean;
3781
- } | {
3782
- source: "file";
3783
- name: string;
3784
- path: string;
3785
- forceStereo: boolean;
3786
- loadAsNone?: boolean | undefined;
3787
- } | {
3788
- source: "url";
3789
- name: string;
3790
- url: string;
3791
- avSyncMsec: number;
3792
- forceStereo: boolean;
3793
- };
3794
- status: {
3795
- led: boolean;
3796
- port?: number | undefined;
3797
- };
3798
- platform: "facebook_rtmp";
3799
- };
3613
+ export declare const isFacebookRtmpStream: (stream: TStream) => stream is TFacebookRtmpStream;
3800
3614
  export type TMpegDvbStream = z.infer<typeof mpegDvbSchema>;
3801
- export declare const isMpegDvbStream: (stream: TStream) => stream is {
3802
- streamId: string;
3803
- enabled: boolean;
3804
- active: boolean;
3805
- title: string;
3806
- callApi: boolean;
3807
- trigger: {
3808
- type: "manual";
3809
- port?: number | undefined;
3810
- } | {
3811
- type: "onetime";
3812
- startTime: number;
3813
- stopTime: number;
3814
- everActivated: boolean;
3815
- prepareAheadS?: number | undefined;
3816
- } | {
3817
- type: "recurrent";
3818
- schedule: {
3819
- start: {
3820
- day: number;
3821
- timeS: number;
3822
- };
3823
- stop: {
3824
- day: number;
3825
- timeS: number;
3826
- };
3827
- isActive: boolean;
3828
- }[];
3829
- prepareAheadS?: number | undefined;
3830
- };
3831
- video: {
3832
- output: {
3833
- type: "video";
3834
- url: string | null;
3835
- parameters: string;
3836
- saveToSdCard?: {
3837
- ruleId: string;
3838
- configurationId: string;
3839
- } | undefined;
3840
- } | {
3841
- type: "images";
3842
- url: string | null;
3843
- imageIntervalS: number;
3844
- } | {
3845
- type: "none";
3846
- saveToSdCard: {
3847
- ruleId: string;
3848
- configurationId: string;
3849
- };
3850
- };
3851
- input: {
3852
- type: "RTSP_URL";
3853
- url: string;
3854
- internalVapixParameters: string;
3855
- } | {
3856
- type: "CSw";
3857
- internalVapixParameters: string;
3858
- } | {
3859
- type: "CRS";
3860
- internalVapixParameters: string;
3861
- userVapixParameters: string;
3862
- };
3863
- delayS?: number | undefined;
3864
- };
3865
- audio: {
3866
- source: "none";
3867
- } | {
3868
- source: "microphone";
3869
- audioChannelNbr: number;
3870
- forceStereo: boolean;
3871
- } | {
3872
- source: "file";
3873
- name: string;
3874
- path: string;
3875
- forceStereo: boolean;
3876
- loadAsNone?: boolean | undefined;
3877
- } | {
3878
- source: "url";
3879
- name: string;
3880
- url: string;
3881
- avSyncMsec: number;
3882
- forceStereo: boolean;
3883
- };
3884
- status: {
3885
- led: boolean;
3886
- port?: number | undefined;
3887
- };
3888
- platform: "mpeg_dvb";
3889
- };
3615
+ export declare const isMpegDvbStream: (stream: TStream) => stream is TMpegDvbStream;
3890
3616
  export type TRtmpStream = z.infer<typeof rtmpSchema>;
3891
- export declare const isRtmpStream: (stream: TStream) => stream is {
3892
- streamId: string;
3893
- enabled: boolean;
3894
- active: boolean;
3895
- title: string;
3896
- callApi: boolean;
3897
- trigger: {
3898
- type: "manual";
3899
- port?: number | undefined;
3900
- } | {
3901
- type: "onetime";
3902
- startTime: number;
3903
- stopTime: number;
3904
- everActivated: boolean;
3905
- prepareAheadS?: number | undefined;
3906
- } | {
3907
- type: "recurrent";
3908
- schedule: {
3909
- start: {
3910
- day: number;
3911
- timeS: number;
3912
- };
3913
- stop: {
3914
- day: number;
3915
- timeS: number;
3916
- };
3917
- isActive: boolean;
3918
- }[];
3919
- prepareAheadS?: number | undefined;
3920
- };
3921
- video: {
3922
- output: {
3923
- type: "video";
3924
- url: string | null;
3925
- parameters: string;
3926
- saveToSdCard?: {
3927
- ruleId: string;
3928
- configurationId: string;
3929
- } | undefined;
3930
- } | {
3931
- type: "images";
3932
- url: string | null;
3933
- imageIntervalS: number;
3934
- } | {
3935
- type: "none";
3936
- saveToSdCard: {
3937
- ruleId: string;
3938
- configurationId: string;
3939
- };
3940
- };
3941
- input: {
3942
- type: "RTSP_URL";
3943
- url: string;
3944
- internalVapixParameters: string;
3945
- } | {
3946
- type: "CSw";
3947
- internalVapixParameters: string;
3948
- } | {
3949
- type: "CRS";
3950
- internalVapixParameters: string;
3951
- userVapixParameters: string;
3952
- };
3953
- delayS?: number | undefined;
3954
- };
3955
- audio: {
3956
- source: "none";
3957
- } | {
3958
- source: "microphone";
3959
- audioChannelNbr: number;
3960
- forceStereo: boolean;
3961
- } | {
3962
- source: "file";
3963
- name: string;
3964
- path: string;
3965
- forceStereo: boolean;
3966
- loadAsNone?: boolean | undefined;
3967
- } | {
3968
- source: "url";
3969
- name: string;
3970
- url: string;
3971
- avSyncMsec: number;
3972
- forceStereo: boolean;
3973
- };
3974
- status: {
3975
- led: boolean;
3976
- port?: number | undefined;
3977
- };
3978
- platform: "rtmp";
3979
- };
3617
+ export declare const isRtmpStream: (stream: TStream) => stream is TRtmpStream;
3980
3618
  export type TSdCardStream = z.infer<typeof sdCardSchema>;
3981
- export declare const isSdCardStream: (stream: TStream) => stream is {
3982
- streamId: string;
3983
- enabled: boolean;
3984
- active: boolean;
3985
- title: string;
3986
- callApi: boolean;
3987
- trigger: {
3988
- type: "manual";
3989
- port?: number | undefined;
3990
- } | {
3991
- type: "onetime";
3992
- startTime: number;
3993
- stopTime: number;
3994
- everActivated: boolean;
3995
- prepareAheadS?: number | undefined;
3996
- } | {
3997
- type: "recurrent";
3998
- schedule: {
3999
- start: {
4000
- day: number;
4001
- timeS: number;
4002
- };
4003
- stop: {
4004
- day: number;
4005
- timeS: number;
4006
- };
4007
- isActive: boolean;
4008
- }[];
4009
- prepareAheadS?: number | undefined;
4010
- };
4011
- video: {
4012
- output: {
4013
- type: "video";
4014
- url: string | null;
4015
- parameters: string;
4016
- saveToSdCard?: {
4017
- ruleId: string;
4018
- configurationId: string;
4019
- } | undefined;
4020
- } | {
4021
- type: "images";
4022
- url: string | null;
4023
- imageIntervalS: number;
4024
- } | {
4025
- type: "none";
4026
- saveToSdCard: {
4027
- ruleId: string;
4028
- configurationId: string;
4029
- };
4030
- };
4031
- input: {
4032
- type: "RTSP_URL";
4033
- url: string;
4034
- internalVapixParameters: string;
4035
- } | {
4036
- type: "CSw";
4037
- internalVapixParameters: string;
4038
- } | {
4039
- type: "CRS";
4040
- internalVapixParameters: string;
4041
- userVapixParameters: string;
4042
- };
4043
- delayS?: number | undefined;
4044
- };
4045
- audio: {
4046
- source: "none";
4047
- } | {
4048
- source: "microphone";
4049
- audioChannelNbr: number;
4050
- forceStereo: boolean;
4051
- } | {
4052
- source: "file";
4053
- name: string;
4054
- path: string;
4055
- forceStereo: boolean;
4056
- loadAsNone?: boolean | undefined;
4057
- } | {
4058
- source: "url";
4059
- name: string;
4060
- url: string;
4061
- avSyncMsec: number;
4062
- forceStereo: boolean;
4063
- };
4064
- status: {
4065
- led: boolean;
4066
- port?: number | undefined;
4067
- };
4068
- platform: "sd_card";
4069
- };
3619
+ export declare const isSdCardStream: (stream: TStream) => stream is TSdCardStream;
4070
3620
  export type TWindyStream = z.infer<typeof windySchema>;
4071
- export declare const isWindyStream: (stream: TStream) => stream is {
4072
- streamId: string;
4073
- enabled: boolean;
4074
- active: boolean;
4075
- title: string;
4076
- callApi: boolean;
4077
- trigger: {
4078
- type: "manual";
4079
- port?: number | undefined;
4080
- } | {
4081
- type: "onetime";
4082
- startTime: number;
4083
- stopTime: number;
4084
- everActivated: boolean;
4085
- prepareAheadS?: number | undefined;
4086
- } | {
4087
- type: "recurrent";
4088
- schedule: {
4089
- start: {
4090
- day: number;
4091
- timeS: number;
4092
- };
4093
- stop: {
4094
- day: number;
4095
- timeS: number;
4096
- };
4097
- isActive: boolean;
4098
- }[];
4099
- prepareAheadS?: number | undefined;
4100
- };
4101
- video: {
4102
- output: {
4103
- type: "video";
4104
- url: string | null;
4105
- parameters: string;
4106
- saveToSdCard?: {
4107
- ruleId: string;
4108
- configurationId: string;
4109
- } | undefined;
4110
- } | {
4111
- type: "images";
4112
- url: string | null;
4113
- imageIntervalS: number;
4114
- } | {
4115
- type: "none";
4116
- saveToSdCard: {
4117
- ruleId: string;
4118
- configurationId: string;
4119
- };
4120
- };
4121
- input: {
4122
- type: "RTSP_URL";
4123
- url: string;
4124
- internalVapixParameters: string;
4125
- } | {
4126
- type: "CSw";
4127
- internalVapixParameters: string;
4128
- } | {
4129
- type: "CRS";
4130
- internalVapixParameters: string;
4131
- userVapixParameters: string;
4132
- };
4133
- delayS?: number | undefined;
4134
- };
4135
- audio: {
4136
- source: "none";
4137
- } | {
4138
- source: "microphone";
4139
- audioChannelNbr: number;
4140
- forceStereo: boolean;
4141
- } | {
4142
- source: "file";
4143
- name: string;
4144
- path: string;
4145
- forceStereo: boolean;
4146
- loadAsNone?: boolean | undefined;
4147
- } | {
4148
- source: "url";
4149
- name: string;
4150
- url: string;
4151
- avSyncMsec: number;
4152
- forceStereo: boolean;
4153
- };
4154
- status: {
4155
- led: boolean;
4156
- port?: number | undefined;
4157
- };
4158
- platform: "windy";
4159
- locationLat: number;
4160
- locationLon: number;
4161
- locationName: string;
4162
- locationAddress: string;
4163
- mapZoom: number;
4164
- direction: z.core.$InferEnumOutput<{
4165
- N: "N";
4166
- NE: "NE";
4167
- E: "E";
4168
- SE: "SE";
4169
- S: "S";
4170
- SW: "SW";
4171
- W: "W";
4172
- NW: "NW";
4173
- }> | null;
4174
- position: "fix" | "rotating" | "controllable";
4175
- webPageUrl: string;
4176
- };
3621
+ export declare const isWindyStream: (stream: TStream) => stream is TWindyStream;
4177
3622
  export type TYouTubeStream = z.infer<typeof youtubeSchema>;
4178
- export declare const isYouTubeStream: (stream: TStream) => stream is {
4179
- streamId: string;
4180
- enabled: boolean;
4181
- active: boolean;
4182
- title: string;
4183
- callApi: boolean;
4184
- trigger: {
4185
- type: "manual";
4186
- port?: number | undefined;
4187
- } | {
4188
- type: "onetime";
4189
- startTime: number;
4190
- stopTime: number;
4191
- everActivated: boolean;
4192
- prepareAheadS?: number | undefined;
4193
- } | {
4194
- type: "recurrent";
4195
- schedule: {
4196
- start: {
4197
- day: number;
4198
- timeS: number;
4199
- };
4200
- stop: {
4201
- day: number;
4202
- timeS: number;
4203
- };
4204
- isActive: boolean;
4205
- }[];
4206
- prepareAheadS?: number | undefined;
4207
- };
4208
- video: {
4209
- output: {
4210
- type: "video";
4211
- url: string | null;
4212
- parameters: string;
4213
- saveToSdCard?: {
4214
- ruleId: string;
4215
- configurationId: string;
4216
- } | undefined;
4217
- } | {
4218
- type: "images";
4219
- url: string | null;
4220
- imageIntervalS: number;
4221
- } | {
4222
- type: "none";
4223
- saveToSdCard: {
4224
- ruleId: string;
4225
- configurationId: string;
4226
- };
4227
- };
4228
- input: {
4229
- type: "RTSP_URL";
4230
- url: string;
4231
- internalVapixParameters: string;
4232
- } | {
4233
- type: "CSw";
4234
- internalVapixParameters: string;
4235
- } | {
4236
- type: "CRS";
4237
- internalVapixParameters: string;
4238
- userVapixParameters: string;
4239
- };
4240
- delayS?: number | undefined;
4241
- };
4242
- audio: {
4243
- source: "none";
4244
- } | {
4245
- source: "microphone";
4246
- audioChannelNbr: number;
4247
- forceStereo: boolean;
4248
- } | {
4249
- source: "file";
4250
- name: string;
4251
- path: string;
4252
- forceStereo: boolean;
4253
- loadAsNone?: boolean | undefined;
4254
- } | {
4255
- source: "url";
4256
- name: string;
4257
- url: string;
4258
- avSyncMsec: number;
4259
- forceStereo: boolean;
4260
- };
4261
- status: {
4262
- led: boolean;
4263
- port?: number | undefined;
4264
- };
4265
- platform: "youtube";
4266
- playlists: string[];
4267
- tags: string[];
4268
- notificationEmails: string[];
4269
- streamPrivacy: "public" | "unlisted" | "private";
4270
- latency: "normal" | "low" | "ultra_low";
4271
- afterEndStatus: "public" | "unlisted" | "private" | "no_change";
4272
- dvr: boolean;
4273
- hasWatchdogs: boolean;
4274
- streamingProtocol: "RTMP" | "RTMPS" | "HLS";
4275
- description?: string | undefined;
4276
- countdown?: boolean | undefined;
4277
- };
3623
+ export declare const isYouTubeStream: (stream: TStream) => stream is TYouTubeStream;
4278
3624
  export type TVimeoStream = z.infer<typeof vimeoSchema>;
4279
- export declare const isVimeoStream: (stream: TStream) => stream is {
4280
- streamId: string;
4281
- enabled: boolean;
4282
- active: boolean;
4283
- title: string;
4284
- callApi: boolean;
4285
- trigger: {
4286
- type: "manual";
4287
- port?: number | undefined;
4288
- } | {
4289
- type: "onetime";
4290
- startTime: number;
4291
- stopTime: number;
4292
- everActivated: boolean;
4293
- prepareAheadS?: number | undefined;
4294
- } | {
4295
- type: "recurrent";
4296
- schedule: {
4297
- start: {
4298
- day: number;
4299
- timeS: number;
4300
- };
4301
- stop: {
4302
- day: number;
4303
- timeS: number;
4304
- };
4305
- isActive: boolean;
4306
- }[];
4307
- prepareAheadS?: number | undefined;
4308
- };
4309
- video: {
4310
- output: {
4311
- type: "video";
4312
- url: string | null;
4313
- parameters: string;
4314
- saveToSdCard?: {
4315
- ruleId: string;
4316
- configurationId: string;
4317
- } | undefined;
4318
- } | {
4319
- type: "images";
4320
- url: string | null;
4321
- imageIntervalS: number;
4322
- } | {
4323
- type: "none";
4324
- saveToSdCard: {
4325
- ruleId: string;
4326
- configurationId: string;
4327
- };
4328
- };
4329
- input: {
4330
- type: "RTSP_URL";
4331
- url: string;
4332
- internalVapixParameters: string;
4333
- } | {
4334
- type: "CSw";
4335
- internalVapixParameters: string;
4336
- } | {
4337
- type: "CRS";
4338
- internalVapixParameters: string;
4339
- userVapixParameters: string;
4340
- };
4341
- delayS?: number | undefined;
4342
- };
4343
- audio: {
4344
- source: "none";
4345
- } | {
4346
- source: "microphone";
4347
- audioChannelNbr: number;
4348
- forceStereo: boolean;
4349
- } | {
4350
- source: "file";
4351
- name: string;
4352
- path: string;
4353
- forceStereo: boolean;
4354
- loadAsNone?: boolean | undefined;
4355
- } | {
4356
- source: "url";
4357
- name: string;
4358
- url: string;
4359
- avSyncMsec: number;
4360
- forceStereo: boolean;
4361
- };
4362
- status: {
4363
- led: boolean;
4364
- port?: number | undefined;
4365
- };
4366
- platform: "vimeo";
4367
- };
3625
+ export declare const isVimeoStream: (stream: TStream) => stream is TVimeoStream;
4368
3626
  export type TTwitchStream = z.infer<typeof twitchSchema>;
4369
- export declare const isTwitchStream: (stream: TStream) => stream is {
4370
- streamId: string;
4371
- enabled: boolean;
4372
- active: boolean;
4373
- title: string;
4374
- callApi: boolean;
4375
- trigger: {
4376
- type: "manual";
4377
- port?: number | undefined;
4378
- } | {
4379
- type: "onetime";
4380
- startTime: number;
4381
- stopTime: number;
4382
- everActivated: boolean;
4383
- prepareAheadS?: number | undefined;
4384
- } | {
4385
- type: "recurrent";
4386
- schedule: {
4387
- start: {
4388
- day: number;
4389
- timeS: number;
4390
- };
4391
- stop: {
4392
- day: number;
4393
- timeS: number;
4394
- };
4395
- isActive: boolean;
4396
- }[];
4397
- prepareAheadS?: number | undefined;
4398
- };
4399
- video: {
4400
- output: {
4401
- type: "video";
4402
- url: string | null;
4403
- parameters: string;
4404
- saveToSdCard?: {
4405
- ruleId: string;
4406
- configurationId: string;
4407
- } | undefined;
4408
- } | {
4409
- type: "images";
4410
- url: string | null;
4411
- imageIntervalS: number;
4412
- } | {
4413
- type: "none";
4414
- saveToSdCard: {
4415
- ruleId: string;
4416
- configurationId: string;
4417
- };
4418
- };
4419
- input: {
4420
- type: "RTSP_URL";
4421
- url: string;
4422
- internalVapixParameters: string;
4423
- } | {
4424
- type: "CSw";
4425
- internalVapixParameters: string;
4426
- } | {
4427
- type: "CRS";
4428
- internalVapixParameters: string;
4429
- userVapixParameters: string;
4430
- };
4431
- delayS?: number | undefined;
4432
- };
4433
- audio: {
4434
- source: "none";
4435
- } | {
4436
- source: "microphone";
4437
- audioChannelNbr: number;
4438
- forceStereo: boolean;
4439
- } | {
4440
- source: "file";
4441
- name: string;
4442
- path: string;
4443
- forceStereo: boolean;
4444
- loadAsNone?: boolean | undefined;
4445
- } | {
4446
- source: "url";
4447
- name: string;
4448
- url: string;
4449
- avSyncMsec: number;
4450
- forceStereo: boolean;
4451
- };
4452
- status: {
4453
- led: boolean;
4454
- port?: number | undefined;
4455
- };
4456
- platform: "twitch";
4457
- };
3627
+ export declare const isTwitchStream: (stream: TStream) => stream is TTwitchStream;
4458
3628
  export type TSrtStream = z.infer<typeof srtSchema>;
4459
- export declare const isSrtStream: (stream: TStream) => stream is {
4460
- streamId: string;
4461
- enabled: boolean;
4462
- active: boolean;
4463
- title: string;
4464
- callApi: boolean;
4465
- trigger: {
4466
- type: "manual";
4467
- port?: number | undefined;
4468
- } | {
4469
- type: "onetime";
4470
- startTime: number;
4471
- stopTime: number;
4472
- everActivated: boolean;
4473
- prepareAheadS?: number | undefined;
4474
- } | {
4475
- type: "recurrent";
4476
- schedule: {
4477
- start: {
4478
- day: number;
4479
- timeS: number;
4480
- };
4481
- stop: {
4482
- day: number;
4483
- timeS: number;
4484
- };
4485
- isActive: boolean;
4486
- }[];
4487
- prepareAheadS?: number | undefined;
4488
- };
4489
- video: {
4490
- output: {
4491
- type: "video";
4492
- url: string | null;
4493
- parameters: string;
4494
- saveToSdCard?: {
4495
- ruleId: string;
4496
- configurationId: string;
4497
- } | undefined;
4498
- } | {
4499
- type: "images";
4500
- url: string | null;
4501
- imageIntervalS: number;
4502
- } | {
4503
- type: "none";
4504
- saveToSdCard: {
4505
- ruleId: string;
4506
- configurationId: string;
4507
- };
4508
- };
4509
- input: {
4510
- type: "RTSP_URL";
4511
- url: string;
4512
- internalVapixParameters: string;
4513
- } | {
4514
- type: "CSw";
4515
- internalVapixParameters: string;
4516
- } | {
4517
- type: "CRS";
4518
- internalVapixParameters: string;
4519
- userVapixParameters: string;
4520
- };
4521
- delayS?: number | undefined;
4522
- };
4523
- audio: {
4524
- source: "none";
4525
- } | {
4526
- source: "microphone";
4527
- audioChannelNbr: number;
4528
- forceStereo: boolean;
4529
- } | {
4530
- source: "file";
4531
- name: string;
4532
- path: string;
4533
- forceStereo: boolean;
4534
- loadAsNone?: boolean | undefined;
4535
- } | {
4536
- source: "url";
4537
- name: string;
4538
- url: string;
4539
- avSyncMsec: number;
4540
- forceStereo: boolean;
4541
- };
4542
- status: {
4543
- led: boolean;
4544
- port?: number | undefined;
4545
- };
4546
- platform: "srt";
4547
- };
3629
+ export declare const isSrtStream: (stream: TStream) => stream is TSrtStream;
4548
3630
  export type TDaCastStream = z.infer<typeof daCastSchema>;
4549
- export declare const isDaCastStream: (stream: TStream) => stream is {
4550
- streamId: string;
4551
- enabled: boolean;
4552
- active: boolean;
4553
- title: string;
4554
- callApi: boolean;
4555
- trigger: {
4556
- type: "manual";
4557
- port?: number | undefined;
4558
- } | {
4559
- type: "onetime";
4560
- startTime: number;
4561
- stopTime: number;
4562
- everActivated: boolean;
4563
- prepareAheadS?: number | undefined;
4564
- } | {
4565
- type: "recurrent";
4566
- schedule: {
4567
- start: {
4568
- day: number;
4569
- timeS: number;
4570
- };
4571
- stop: {
4572
- day: number;
4573
- timeS: number;
4574
- };
4575
- isActive: boolean;
4576
- }[];
4577
- prepareAheadS?: number | undefined;
4578
- };
4579
- video: {
4580
- output: {
4581
- type: "video";
4582
- url: string | null;
4583
- parameters: string;
4584
- saveToSdCard?: {
4585
- ruleId: string;
4586
- configurationId: string;
4587
- } | undefined;
4588
- } | {
4589
- type: "images";
4590
- url: string | null;
4591
- imageIntervalS: number;
4592
- } | {
4593
- type: "none";
4594
- saveToSdCard: {
4595
- ruleId: string;
4596
- configurationId: string;
4597
- };
4598
- };
4599
- input: {
4600
- type: "RTSP_URL";
4601
- url: string;
4602
- internalVapixParameters: string;
4603
- } | {
4604
- type: "CSw";
4605
- internalVapixParameters: string;
4606
- } | {
4607
- type: "CRS";
4608
- internalVapixParameters: string;
4609
- userVapixParameters: string;
4610
- };
4611
- delayS?: number | undefined;
4612
- };
4613
- audio: {
4614
- source: "none";
4615
- } | {
4616
- source: "microphone";
4617
- audioChannelNbr: number;
4618
- forceStereo: boolean;
4619
- } | {
4620
- source: "file";
4621
- name: string;
4622
- path: string;
4623
- forceStereo: boolean;
4624
- loadAsNone?: boolean | undefined;
4625
- } | {
4626
- source: "url";
4627
- name: string;
4628
- url: string;
4629
- avSyncMsec: number;
4630
- forceStereo: boolean;
4631
- };
4632
- status: {
4633
- led: boolean;
4634
- port?: number | undefined;
4635
- };
4636
- platform: "da_cast";
4637
- };
3631
+ export declare const isDaCastStream: (stream: TStream) => stream is TDaCastStream;
4638
3632
  export type THlsPullStream = z.infer<typeof hlsPullSchema>;
4639
- export declare const isHlsPullStream: (stream: TStream) => stream is {
4640
- streamId: string;
4641
- enabled: boolean;
4642
- active: boolean;
4643
- title: string;
4644
- callApi: boolean;
4645
- trigger: {
4646
- type: "manual";
4647
- port?: number | undefined;
4648
- } | {
4649
- type: "onetime";
4650
- startTime: number;
4651
- stopTime: number;
4652
- everActivated: boolean;
4653
- prepareAheadS?: number | undefined;
4654
- } | {
4655
- type: "recurrent";
4656
- schedule: {
4657
- start: {
4658
- day: number;
4659
- timeS: number;
4660
- };
4661
- stop: {
4662
- day: number;
4663
- timeS: number;
4664
- };
4665
- isActive: boolean;
4666
- }[];
4667
- prepareAheadS?: number | undefined;
4668
- };
4669
- video: {
4670
- output: {
4671
- type: "video";
4672
- url: string | null;
4673
- parameters: string;
4674
- saveToSdCard?: {
4675
- ruleId: string;
4676
- configurationId: string;
4677
- } | undefined;
4678
- } | {
4679
- type: "images";
4680
- url: string | null;
4681
- imageIntervalS: number;
4682
- } | {
4683
- type: "none";
4684
- saveToSdCard: {
4685
- ruleId: string;
4686
- configurationId: string;
4687
- };
4688
- };
4689
- input: {
4690
- type: "RTSP_URL";
4691
- url: string;
4692
- internalVapixParameters: string;
4693
- } | {
4694
- type: "CSw";
4695
- internalVapixParameters: string;
4696
- } | {
4697
- type: "CRS";
4698
- internalVapixParameters: string;
4699
- userVapixParameters: string;
4700
- };
4701
- delayS?: number | undefined;
4702
- };
4703
- audio: {
4704
- source: "none";
4705
- } | {
4706
- source: "microphone";
4707
- audioChannelNbr: number;
4708
- forceStereo: boolean;
4709
- } | {
4710
- source: "file";
4711
- name: string;
4712
- path: string;
4713
- forceStereo: boolean;
4714
- loadAsNone?: boolean | undefined;
4715
- } | {
4716
- source: "url";
4717
- name: string;
4718
- url: string;
4719
- avSyncMsec: number;
4720
- forceStereo: boolean;
4721
- };
4722
- status: {
4723
- led: boolean;
4724
- port?: number | undefined;
4725
- };
4726
- platform: "hls_pull";
4727
- };
3633
+ export declare const isHlsPullStream: (stream: TStream) => stream is THlsPullStream;
4728
3634
  export type THlsPushStream = z.infer<typeof hlsPushSchema>;
4729
- export declare const isHlsPushStream: (stream: TStream) => stream is {
4730
- streamId: string;
4731
- enabled: boolean;
4732
- active: boolean;
4733
- title: string;
4734
- callApi: boolean;
4735
- trigger: {
4736
- type: "manual";
4737
- port?: number | undefined;
4738
- } | {
4739
- type: "onetime";
4740
- startTime: number;
4741
- stopTime: number;
4742
- everActivated: boolean;
4743
- prepareAheadS?: number | undefined;
4744
- } | {
4745
- type: "recurrent";
4746
- schedule: {
4747
- start: {
4748
- day: number;
4749
- timeS: number;
4750
- };
4751
- stop: {
4752
- day: number;
4753
- timeS: number;
4754
- };
4755
- isActive: boolean;
4756
- }[];
4757
- prepareAheadS?: number | undefined;
4758
- };
4759
- video: {
4760
- output: {
4761
- type: "video";
4762
- url: string | null;
4763
- parameters: string;
4764
- saveToSdCard?: {
4765
- ruleId: string;
4766
- configurationId: string;
4767
- } | undefined;
4768
- } | {
4769
- type: "images";
4770
- url: string | null;
4771
- imageIntervalS: number;
4772
- } | {
4773
- type: "none";
4774
- saveToSdCard: {
4775
- ruleId: string;
4776
- configurationId: string;
4777
- };
4778
- };
4779
- input: {
4780
- type: "RTSP_URL";
4781
- url: string;
4782
- internalVapixParameters: string;
4783
- } | {
4784
- type: "CSw";
4785
- internalVapixParameters: string;
4786
- } | {
4787
- type: "CRS";
4788
- internalVapixParameters: string;
4789
- userVapixParameters: string;
4790
- };
4791
- delayS?: number | undefined;
4792
- };
4793
- audio: {
4794
- source: "none";
4795
- } | {
4796
- source: "microphone";
4797
- audioChannelNbr: number;
4798
- forceStereo: boolean;
4799
- } | {
4800
- source: "file";
4801
- name: string;
4802
- path: string;
4803
- forceStereo: boolean;
4804
- loadAsNone?: boolean | undefined;
4805
- } | {
4806
- source: "url";
4807
- name: string;
4808
- url: string;
4809
- avSyncMsec: number;
4810
- forceStereo: boolean;
4811
- };
4812
- status: {
4813
- led: boolean;
4814
- port?: number | undefined;
4815
- };
4816
- platform: "hls_push";
4817
- };
3635
+ export declare const isHlsPushStream: (stream: TStream) => stream is THlsPushStream;
4818
3636
  export type TWowzaStream = z.infer<typeof wowzaSchema>;
4819
- export declare const isWowzaStream: (stream: TStream) => stream is {
4820
- streamId: string;
4821
- enabled: boolean;
4822
- active: boolean;
4823
- title: string;
4824
- callApi: boolean;
4825
- trigger: {
4826
- type: "manual";
4827
- port?: number | undefined;
4828
- } | {
4829
- type: "onetime";
4830
- startTime: number;
4831
- stopTime: number;
4832
- everActivated: boolean;
4833
- prepareAheadS?: number | undefined;
4834
- } | {
4835
- type: "recurrent";
4836
- schedule: {
4837
- start: {
4838
- day: number;
4839
- timeS: number;
4840
- };
4841
- stop: {
4842
- day: number;
4843
- timeS: number;
4844
- };
4845
- isActive: boolean;
4846
- }[];
4847
- prepareAheadS?: number | undefined;
4848
- };
4849
- video: {
4850
- output: {
4851
- type: "video";
4852
- url: string | null;
4853
- parameters: string;
4854
- saveToSdCard?: {
4855
- ruleId: string;
4856
- configurationId: string;
4857
- } | undefined;
4858
- } | {
4859
- type: "images";
4860
- url: string | null;
4861
- imageIntervalS: number;
4862
- } | {
4863
- type: "none";
4864
- saveToSdCard: {
4865
- ruleId: string;
4866
- configurationId: string;
4867
- };
4868
- };
4869
- input: {
4870
- type: "RTSP_URL";
4871
- url: string;
4872
- internalVapixParameters: string;
4873
- } | {
4874
- type: "CSw";
4875
- internalVapixParameters: string;
4876
- } | {
4877
- type: "CRS";
4878
- internalVapixParameters: string;
4879
- userVapixParameters: string;
4880
- };
4881
- delayS?: number | undefined;
4882
- };
4883
- audio: {
4884
- source: "none";
4885
- } | {
4886
- source: "microphone";
4887
- audioChannelNbr: number;
4888
- forceStereo: boolean;
4889
- } | {
4890
- source: "file";
4891
- name: string;
4892
- path: string;
4893
- forceStereo: boolean;
4894
- loadAsNone?: boolean | undefined;
4895
- } | {
4896
- source: "url";
4897
- name: string;
4898
- url: string;
4899
- avSyncMsec: number;
4900
- forceStereo: boolean;
4901
- };
4902
- status: {
4903
- led: boolean;
4904
- port?: number | undefined;
4905
- };
4906
- platform: "wowza";
4907
- };
3637
+ export declare const isWowzaStream: (stream: TStream) => stream is TWowzaStream;
4908
3638
  export type TDailymotionStream = z.infer<typeof dailymotionSchema>;
4909
- export declare const isDailymotionStream: (stream: TStream) => stream is {
4910
- streamId: string;
4911
- enabled: boolean;
4912
- active: boolean;
4913
- title: string;
4914
- callApi: boolean;
4915
- trigger: {
4916
- type: "manual";
4917
- port?: number | undefined;
4918
- } | {
4919
- type: "onetime";
4920
- startTime: number;
4921
- stopTime: number;
4922
- everActivated: boolean;
4923
- prepareAheadS?: number | undefined;
4924
- } | {
4925
- type: "recurrent";
4926
- schedule: {
4927
- start: {
4928
- day: number;
4929
- timeS: number;
4930
- };
4931
- stop: {
4932
- day: number;
4933
- timeS: number;
4934
- };
4935
- isActive: boolean;
4936
- }[];
4937
- prepareAheadS?: number | undefined;
4938
- };
4939
- video: {
4940
- output: {
4941
- type: "video";
4942
- url: string | null;
4943
- parameters: string;
4944
- saveToSdCard?: {
4945
- ruleId: string;
4946
- configurationId: string;
4947
- } | undefined;
4948
- } | {
4949
- type: "images";
4950
- url: string | null;
4951
- imageIntervalS: number;
4952
- } | {
4953
- type: "none";
4954
- saveToSdCard: {
4955
- ruleId: string;
4956
- configurationId: string;
4957
- };
4958
- };
4959
- input: {
4960
- type: "RTSP_URL";
4961
- url: string;
4962
- internalVapixParameters: string;
4963
- } | {
4964
- type: "CSw";
4965
- internalVapixParameters: string;
4966
- } | {
4967
- type: "CRS";
4968
- internalVapixParameters: string;
4969
- userVapixParameters: string;
4970
- };
4971
- delayS?: number | undefined;
4972
- };
4973
- audio: {
4974
- source: "none";
4975
- } | {
4976
- source: "microphone";
4977
- audioChannelNbr: number;
4978
- forceStereo: boolean;
4979
- } | {
4980
- source: "file";
4981
- name: string;
4982
- path: string;
4983
- forceStereo: boolean;
4984
- loadAsNone?: boolean | undefined;
4985
- } | {
4986
- source: "url";
4987
- name: string;
4988
- url: string;
4989
- avSyncMsec: number;
4990
- forceStereo: boolean;
4991
- };
4992
- status: {
4993
- led: boolean;
4994
- port?: number | undefined;
4995
- };
4996
- platform: "dailymotion";
4997
- };
3639
+ export declare const isDailymotionStream: (stream: TStream) => stream is TDailymotionStream;
4998
3640
  export type TIbmStream = z.infer<typeof ibmSchema>;
4999
- export declare const isIbmStream: (stream: TStream) => stream is {
5000
- streamId: string;
5001
- enabled: boolean;
5002
- active: boolean;
5003
- title: string;
5004
- callApi: boolean;
5005
- trigger: {
5006
- type: "manual";
5007
- port?: number | undefined;
5008
- } | {
5009
- type: "onetime";
5010
- startTime: number;
5011
- stopTime: number;
5012
- everActivated: boolean;
5013
- prepareAheadS?: number | undefined;
5014
- } | {
5015
- type: "recurrent";
5016
- schedule: {
5017
- start: {
5018
- day: number;
5019
- timeS: number;
5020
- };
5021
- stop: {
5022
- day: number;
5023
- timeS: number;
5024
- };
5025
- isActive: boolean;
5026
- }[];
5027
- prepareAheadS?: number | undefined;
5028
- };
5029
- video: {
5030
- output: {
5031
- type: "video";
5032
- url: string | null;
5033
- parameters: string;
5034
- saveToSdCard?: {
5035
- ruleId: string;
5036
- configurationId: string;
5037
- } | undefined;
5038
- } | {
5039
- type: "images";
5040
- url: string | null;
5041
- imageIntervalS: number;
5042
- } | {
5043
- type: "none";
5044
- saveToSdCard: {
5045
- ruleId: string;
5046
- configurationId: string;
5047
- };
5048
- };
5049
- input: {
5050
- type: "RTSP_URL";
5051
- url: string;
5052
- internalVapixParameters: string;
5053
- } | {
5054
- type: "CSw";
5055
- internalVapixParameters: string;
5056
- } | {
5057
- type: "CRS";
5058
- internalVapixParameters: string;
5059
- userVapixParameters: string;
5060
- };
5061
- delayS?: number | undefined;
5062
- };
5063
- audio: {
5064
- source: "none";
5065
- } | {
5066
- source: "microphone";
5067
- audioChannelNbr: number;
5068
- forceStereo: boolean;
5069
- } | {
5070
- source: "file";
5071
- name: string;
5072
- path: string;
5073
- forceStereo: boolean;
5074
- loadAsNone?: boolean | undefined;
5075
- } | {
5076
- source: "url";
5077
- name: string;
5078
- url: string;
5079
- avSyncMsec: number;
5080
- forceStereo: boolean;
5081
- };
5082
- status: {
5083
- led: boolean;
5084
- port?: number | undefined;
5085
- };
5086
- platform: "ibm";
5087
- };
3641
+ export declare const isIbmStream: (stream: TStream) => stream is TIbmStream;
5088
3642
  export type TMicrosoftAzureStream = z.infer<typeof microsoftAzureSchema>;
5089
- export declare const isMicrosoftAzureStream: (stream: TStream) => stream is {
5090
- streamId: string;
5091
- enabled: boolean;
5092
- active: boolean;
5093
- title: string;
5094
- callApi: boolean;
5095
- trigger: {
5096
- type: "manual";
5097
- port?: number | undefined;
5098
- } | {
5099
- type: "onetime";
5100
- startTime: number;
5101
- stopTime: number;
5102
- everActivated: boolean;
5103
- prepareAheadS?: number | undefined;
5104
- } | {
5105
- type: "recurrent";
5106
- schedule: {
5107
- start: {
5108
- day: number;
5109
- timeS: number;
5110
- };
5111
- stop: {
5112
- day: number;
5113
- timeS: number;
5114
- };
5115
- isActive: boolean;
5116
- }[];
5117
- prepareAheadS?: number | undefined;
5118
- };
5119
- video: {
5120
- output: {
5121
- type: "video";
5122
- url: string | null;
5123
- parameters: string;
5124
- saveToSdCard?: {
5125
- ruleId: string;
5126
- configurationId: string;
5127
- } | undefined;
5128
- } | {
5129
- type: "images";
5130
- url: string | null;
5131
- imageIntervalS: number;
5132
- } | {
5133
- type: "none";
5134
- saveToSdCard: {
5135
- ruleId: string;
5136
- configurationId: string;
5137
- };
5138
- };
5139
- input: {
5140
- type: "RTSP_URL";
5141
- url: string;
5142
- internalVapixParameters: string;
5143
- } | {
5144
- type: "CSw";
5145
- internalVapixParameters: string;
5146
- } | {
5147
- type: "CRS";
5148
- internalVapixParameters: string;
5149
- userVapixParameters: string;
5150
- };
5151
- delayS?: number | undefined;
5152
- };
5153
- audio: {
5154
- source: "none";
5155
- } | {
5156
- source: "microphone";
5157
- audioChannelNbr: number;
5158
- forceStereo: boolean;
5159
- } | {
5160
- source: "file";
5161
- name: string;
5162
- path: string;
5163
- forceStereo: boolean;
5164
- loadAsNone?: boolean | undefined;
5165
- } | {
5166
- source: "url";
5167
- name: string;
5168
- url: string;
5169
- avSyncMsec: number;
5170
- forceStereo: boolean;
5171
- };
5172
- status: {
5173
- led: boolean;
5174
- port?: number | undefined;
5175
- };
5176
- platform: "microsoft_azure";
5177
- };
3643
+ export declare const isMicrosoftAzureStream: (stream: TStream) => stream is TMicrosoftAzureStream;
5178
3644
  export type TMicrosoftStream = z.infer<typeof microsoftStreamSchema>;
5179
- export declare const isMicrosoftStream: (stream: TStream) => stream is {
5180
- streamId: string;
5181
- enabled: boolean;
5182
- active: boolean;
5183
- title: string;
5184
- callApi: boolean;
5185
- trigger: {
5186
- type: "manual";
5187
- port?: number | undefined;
5188
- } | {
5189
- type: "onetime";
5190
- startTime: number;
5191
- stopTime: number;
5192
- everActivated: boolean;
5193
- prepareAheadS?: number | undefined;
5194
- } | {
5195
- type: "recurrent";
5196
- schedule: {
5197
- start: {
5198
- day: number;
5199
- timeS: number;
5200
- };
5201
- stop: {
5202
- day: number;
5203
- timeS: number;
5204
- };
5205
- isActive: boolean;
5206
- }[];
5207
- prepareAheadS?: number | undefined;
5208
- };
5209
- video: {
5210
- output: {
5211
- type: "video";
5212
- url: string | null;
5213
- parameters: string;
5214
- saveToSdCard?: {
5215
- ruleId: string;
5216
- configurationId: string;
5217
- } | undefined;
5218
- } | {
5219
- type: "images";
5220
- url: string | null;
5221
- imageIntervalS: number;
5222
- } | {
5223
- type: "none";
5224
- saveToSdCard: {
5225
- ruleId: string;
5226
- configurationId: string;
5227
- };
5228
- };
5229
- input: {
5230
- type: "RTSP_URL";
5231
- url: string;
5232
- internalVapixParameters: string;
5233
- } | {
5234
- type: "CSw";
5235
- internalVapixParameters: string;
5236
- } | {
5237
- type: "CRS";
5238
- internalVapixParameters: string;
5239
- userVapixParameters: string;
5240
- };
5241
- delayS?: number | undefined;
5242
- };
5243
- audio: {
5244
- source: "none";
5245
- } | {
5246
- source: "microphone";
5247
- audioChannelNbr: number;
5248
- forceStereo: boolean;
5249
- } | {
5250
- source: "file";
5251
- name: string;
5252
- path: string;
5253
- forceStereo: boolean;
5254
- loadAsNone?: boolean | undefined;
5255
- } | {
5256
- source: "url";
5257
- name: string;
5258
- url: string;
5259
- avSyncMsec: number;
5260
- forceStereo: boolean;
5261
- };
5262
- status: {
5263
- led: boolean;
5264
- port?: number | undefined;
5265
- };
5266
- platform: "microsoft_stream";
5267
- };
3645
+ export declare const isMicrosoftStream: (stream: TStream) => stream is TMicrosoftStream;
5268
3646
  export type TGameChangerStream = z.infer<typeof gameChangerSchema>;
5269
- export declare const isGameChangerStream: (stream: TStream) => stream is {
5270
- streamId: string;
5271
- enabled: boolean;
5272
- active: boolean;
5273
- title: string;
5274
- callApi: boolean;
5275
- trigger: {
5276
- type: "manual";
5277
- port?: number | undefined;
5278
- } | {
5279
- type: "onetime";
5280
- startTime: number;
5281
- stopTime: number;
5282
- everActivated: boolean;
5283
- prepareAheadS?: number | undefined;
5284
- } | {
5285
- type: "recurrent";
5286
- schedule: {
5287
- start: {
5288
- day: number;
5289
- timeS: number;
5290
- };
5291
- stop: {
5292
- day: number;
5293
- timeS: number;
5294
- };
5295
- isActive: boolean;
5296
- }[];
5297
- prepareAheadS?: number | undefined;
5298
- };
5299
- video: {
5300
- output: {
5301
- type: "video";
5302
- url: string | null;
5303
- parameters: string;
5304
- saveToSdCard?: {
5305
- ruleId: string;
5306
- configurationId: string;
5307
- } | undefined;
5308
- } | {
5309
- type: "images";
5310
- url: string | null;
5311
- imageIntervalS: number;
5312
- } | {
5313
- type: "none";
5314
- saveToSdCard: {
5315
- ruleId: string;
5316
- configurationId: string;
5317
- };
5318
- };
5319
- input: {
5320
- type: "RTSP_URL";
5321
- url: string;
5322
- internalVapixParameters: string;
5323
- } | {
5324
- type: "CSw";
5325
- internalVapixParameters: string;
5326
- } | {
5327
- type: "CRS";
5328
- internalVapixParameters: string;
5329
- userVapixParameters: string;
5330
- };
5331
- delayS?: number | undefined;
5332
- };
5333
- audio: {
5334
- source: "none";
5335
- } | {
5336
- source: "microphone";
5337
- audioChannelNbr: number;
5338
- forceStereo: boolean;
5339
- } | {
5340
- source: "file";
5341
- name: string;
5342
- path: string;
5343
- forceStereo: boolean;
5344
- loadAsNone?: boolean | undefined;
5345
- } | {
5346
- source: "url";
5347
- name: string;
5348
- url: string;
5349
- avSyncMsec: number;
5350
- forceStereo: boolean;
5351
- };
5352
- status: {
5353
- led: boolean;
5354
- port?: number | undefined;
5355
- };
5356
- platform: "game_changer";
5357
- };
3647
+ export declare const isGameChangerStream: (stream: TStream) => stream is TGameChangerStream;
5358
3648
  export type TYoutubeRtmpStream = z.infer<typeof youtubeRtmpSchema>;
5359
- export declare const isYoutubeRtmpStream: (stream: TStream) => stream is {
5360
- streamId: string;
5361
- enabled: boolean;
5362
- active: boolean;
5363
- title: string;
5364
- callApi: boolean;
5365
- trigger: {
5366
- type: "manual";
5367
- port?: number | undefined;
5368
- } | {
5369
- type: "onetime";
5370
- startTime: number;
5371
- stopTime: number;
5372
- everActivated: boolean;
5373
- prepareAheadS?: number | undefined;
5374
- } | {
5375
- type: "recurrent";
5376
- schedule: {
5377
- start: {
5378
- day: number;
5379
- timeS: number;
5380
- };
5381
- stop: {
5382
- day: number;
5383
- timeS: number;
5384
- };
5385
- isActive: boolean;
5386
- }[];
5387
- prepareAheadS?: number | undefined;
5388
- };
5389
- video: {
5390
- output: {
5391
- type: "video";
5392
- url: string | null;
5393
- parameters: string;
5394
- saveToSdCard?: {
5395
- ruleId: string;
5396
- configurationId: string;
5397
- } | undefined;
5398
- } | {
5399
- type: "images";
5400
- url: string | null;
5401
- imageIntervalS: number;
5402
- } | {
5403
- type: "none";
5404
- saveToSdCard: {
5405
- ruleId: string;
5406
- configurationId: string;
5407
- };
5408
- };
5409
- input: {
5410
- type: "RTSP_URL";
5411
- url: string;
5412
- internalVapixParameters: string;
5413
- } | {
5414
- type: "CSw";
5415
- internalVapixParameters: string;
5416
- } | {
5417
- type: "CRS";
5418
- internalVapixParameters: string;
5419
- userVapixParameters: string;
5420
- };
5421
- delayS?: number | undefined;
5422
- };
5423
- audio: {
5424
- source: "none";
5425
- } | {
5426
- source: "microphone";
5427
- audioChannelNbr: number;
5428
- forceStereo: boolean;
5429
- } | {
5430
- source: "file";
5431
- name: string;
5432
- path: string;
5433
- forceStereo: boolean;
5434
- loadAsNone?: boolean | undefined;
5435
- } | {
5436
- source: "url";
5437
- name: string;
5438
- url: string;
5439
- avSyncMsec: number;
5440
- forceStereo: boolean;
5441
- };
5442
- status: {
5443
- led: boolean;
5444
- port?: number | undefined;
5445
- };
5446
- platform: "youtube_rtmp";
5447
- };
3649
+ export declare const isYoutubeRtmpStream: (stream: TStream) => stream is TYoutubeRtmpStream;
5448
3650
  export declare enum AudioType {
5449
3651
  MP3 = 0,
5450
3652
  AAC = 1