obws 0.15.0

The obws (obvious) remote control library for OBS.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286

//! Requests related to inputs.

use serde::Serialize;
use serde_with::skip_serializing_none;
use time::Duration;

pub use super::ids::InputId;
use super::scenes::SceneId;
use crate::common::{DeinterlaceFieldOrder, DeinterlaceMode, MonitorType};

#[derive(Serialize)]
#[serde(tag = "requestType", content = "requestData")]
pub(crate) enum Request<'a> {
    #[serde(rename = "GetInputList")]
    List {
        /// Restrict the array to only inputs of the specified kind.
        #[serde(rename = "inputKind", skip_serializing_if = "Option::is_none")]
        kind: Option<&'a str>,
    },
    #[serde(rename = "GetInputKindList")]
    ListKinds {
        /// Return all kinds as unversioned or with version suffixes (if available).
        #[serde(rename = "unversioned")]
        unversioned: bool,
    },
    #[serde(rename = "GetSpecialInputs")]
    Specials,
    #[serde(rename = "GetInputDefaultSettings")]
    DefaultSettings {
        /// Input kind to get the default settings for.
        #[serde(rename = "inputKind")]
        kind: &'a str,
    },
    #[serde(rename = "GetInputSettings")]
    Settings {
        /// The input to get the settings of.
        #[serde(flatten)]
        input: InputId<'a>,
    },
    #[serde(rename = "SetInputSettings")]
    SetSettings(SetSettingsInternal<'a>),
    #[serde(rename = "GetInputMute")]
    Muted {
        /// The input to get the mute state of.
        #[serde(flatten)]
        input: InputId<'a>,
    },
    #[serde(rename = "SetInputMute")]
    SetMuted {
        /// The input to set the mute state of.
        #[serde(flatten)]
        input: InputId<'a>,
        /// Whether to mute the input.
        #[serde(rename = "inputMuted")]
        muted: bool,
    },
    #[serde(rename = "ToggleInputMute")]
    ToggleMute {
        /// The input to toggle the mute state of.
        #[serde(flatten)]
        input: InputId<'a>,
    },
    #[serde(rename = "GetInputVolume")]
    Volume {
        /// The input to get the volume of.
        #[serde(flatten)]
        input: InputId<'a>,
    },
    #[serde(rename = "SetInputVolume")]
    SetVolume {
        /// The input to set the volume of.
        #[serde(flatten)]
        input: InputId<'a>,
        /// Volume settings in either mul or dB.
        #[serde(rename = "volume", flatten)]
        volume: Volume,
    },
    #[serde(rename = "SetInputName")]
    SetName {
        /// Current input.
        #[serde(flatten)]
        input: InputId<'a>,
        /// New name for the input.
        #[serde(rename = "newInputName")]
        new: &'a str,
    },
    #[serde(rename = "CreateInput")]
    Create(CreateInputInternal<'a>),
    #[serde(rename = "RemoveInput")]
    Remove {
        /// The input to remove.
        #[serde(flatten)]
        input: InputId<'a>,
    },
    #[serde(rename = "GetInputAudioBalance")]
    AudioBalance {
        /// The input to get the audio balance of.
        #[serde(flatten)]
        input: InputId<'a>,
    },
    #[serde(rename = "SetInputAudioBalance")]
    SetAudioBalance {
        /// The input to set the audio balance of.
        #[serde(flatten)]
        input: InputId<'a>,
        /// New audio balance value. Must be in range of `0.0..=1.0`.
        #[serde(rename = "inputAudioBalance")]
        balance: f32,
    },
    #[serde(rename = "GetInputAudioSyncOffset")]
    AudioSyncOffset {
        /// The input to get the audio sync offset of.
        #[serde(flatten)]
        input: InputId<'a>,
    },
    #[serde(rename = "SetInputAudioSyncOffset")]
    SetAudioSyncOffset {
        /// The input to set the audio sync offset of.
        #[serde(flatten)]
        input: InputId<'a>,
        /// New audio sync offset in milliseconds.
        #[serde(
            rename = "inputAudioSyncOffset",
            with = "crate::serde::duration_millis"
        )]
        offset: Duration,
    },
    #[serde(rename = "GetInputAudioMonitorType")]
    AudioMonitorType {
        /// The input to get the audio monitor type of.
        #[serde(flatten)]
        input: InputId<'a>,
    },
    #[serde(rename = "SetInputAudioMonitorType")]
    SetAudioMonitorType {
        /// The input to set the audio monitor type of.
        #[serde(flatten)]
        input: InputId<'a>,
        /// Audio monitor type.
        #[serde(rename = "monitorType")]
        monitor_type: MonitorType,
    },
    #[serde(rename = "GetInputAudioTracks")]
    AudioTracks {
        /// Identifier of the input.
        #[serde(flatten)]
        input: InputId<'a>,
    },
    #[serde(rename = "SetInputAudioTracks")]
    SetAudioTracks {
        /// Identifier of the input.
        #[serde(flatten)]
        input: InputId<'a>,
        /// Track settings to apply.
        #[serde(
            rename = "inputAudioTracks",
            with = "crate::serde::audio_tracks::option"
        )]
        tracks: [Option<bool>; 6],
    },
    #[serde(rename = "GetInputDeinterlaceMode")]
    DeinterlaceMode {
        /// Identifier of the input.
        #[serde(flatten)]
        input: InputId<'a>,
    },
    #[serde(rename = "SetInputDeinterlaceMode")]
    SetDeinterlaceMode {
        /// Identifier of the input.
        #[serde(flatten)]
        input: InputId<'a>,
        /// Deinterlace mode for the input.
        #[serde(rename = "inputDeinterlaceMode")]
        mode: DeinterlaceMode,
    },
    #[serde(rename = "GetInputDeinterlaceFieldOrder")]
    DeinterlaceFieldOrder {
        /// Identifier of the input.
        #[serde(flatten)]
        input: InputId<'a>,
    },
    #[serde(rename = "SetInputDeinterlaceFieldOrder")]
    SetDeinterlaceFieldOrder {
        /// Identifier of the input.
        #[serde(flatten)]
        input: InputId<'a>,
        /// Deinterlace field order for the input.
        #[serde(rename = "inputDeinterlaceFieldOrder")]
        field_order: DeinterlaceFieldOrder,
    },
    #[serde(rename = "GetInputPropertiesListPropertyItems")]
    PropertiesListPropertyItems {
        /// Identifier of the input.
        #[serde(flatten)]
        input: InputId<'a>,
        /// Name of the list property to get the items of.
        #[serde(rename = "propertyName")]
        property: &'a str,
    },
    #[serde(rename = "PressInputPropertiesButton")]
    PressPropertiesButton {
        /// Identifier of the input.
        #[serde(flatten)]
        input: InputId<'a>,
        /// Name of the button property to press.
        #[serde(rename = "propertyName")]
        property: &'a str,
    },
}

impl<'a> From<Request<'a>> for super::RequestType<'a> {
    fn from(value: Request<'a>) -> Self {
        super::RequestType::Inputs(value)
    }
}

/// Request information for [`crate::client::Inputs::set_settings`].
#[cfg_attr(feature = "builder", derive(bon::Builder))]
pub struct SetSettings<'a, T> {
    /// The input to set the settings of.
    pub input: InputId<'a>,
    /// Object of settings to apply.
    pub settings: &'a T,
    /// Apply settings on top of existing ones or reset the input to its defaults, then apply
    /// settings.
    pub overlay: Option<bool>,
}

/// Request information for [`crate::client::Inputs::set_settings`].
#[skip_serializing_none]
#[derive(Default, Serialize)]
pub(crate) struct SetSettingsInternal<'a> {
    /// The input to set the settings of.
    #[serde(flatten)]
    pub input: InputId<'a>,
    /// Object of settings to apply.
    #[serde(rename = "inputSettings")]
    pub settings: serde_json::Value,
    /// Apply settings on top of existing ones or reset the input to its defaults, then apply
    /// settings.
    #[serde(rename = "overlay")]
    pub overlay: Option<bool>,
}

/// Request information for [`crate::client::Inputs::set_volume`].
#[derive(Serialize)]
#[non_exhaustive]
pub enum Volume {
    /// Volume setting in mul.
    #[serde(rename = "inputVolumeMul")]
    Mul(f32),
    /// Volume setting in dB.
    #[serde(rename = "inputVolumeDb")]
    Db(f32),
}

/// Request information for [`crate::client::Inputs::create`].
#[cfg_attr(feature = "builder", derive(bon::Builder))]
pub struct Create<'a, T> {
    /// Name of the scene to add the input to as a scene item.
    pub scene: SceneId<'a>,
    /// Name of the new input to created.
    pub input: &'a str,
    /// The kind of input to be created.
    pub kind: &'a str,
    /// Settings object to initialize the input with.
    pub settings: Option<T>,
    /// Whether to set the created scene item to enabled or disabled.
    pub enabled: Option<bool>,
}

/// Request information for [`crate::client::Inputs::create`].
#[skip_serializing_none]
#[derive(Default, Serialize)]
pub(crate) struct CreateInputInternal<'a> {
    #[serde(flatten)]
    pub scene: SceneId<'a>,
    #[serde(rename = "inputName")]
    pub input: &'a str,
    #[serde(rename = "inputKind")]
    pub kind: &'a str,
    #[serde(rename = "inputSettings")]
    pub settings: Option<serde_json::Value>,
    #[serde(rename = "sceneItemEnabled")]
    pub enabled: Option<bool>,
}