5class AudioChannels(str, Enum):
 6    """None"""
 7
 8    MONO = "mono"
 9    STEREO = "stereo"
10
11    def __str__(self) -> str:
12        return str(self.value)

 5class AudioMixingStrategy(str, Enum):
 6    """None"""
 7
 8    SUM_CLIP = "sum_clip"
 9    SUM_SCALE = "sum_scale"
10
11    def __str__(self) -> str:
12        return str(self.value)

16@_attrs_define
17class AudioScene:
18    """
19    Attributes:
20        inputs (list[AudioSceneInput]):
21    """
22
23    inputs: list[AudioSceneInput]
24
25    def to_dict(self) -> dict[str, Any]:
26        inputs = []
27        for inputs_item_data in self.inputs:
28            inputs_item = inputs_item_data.to_dict()
29            inputs.append(inputs_item)
30
31        field_dict: dict[str, Any] = {}
32
33        field_dict.update({
34            "inputs": inputs,
35        })
36
37        return field_dict
38
39    @classmethod
40    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
41        from ..models.audio_scene_input import AudioSceneInput
42
43        d = dict(src_dict)
44        inputs = []
45        _inputs = d.pop("inputs")
46        for inputs_item_data in _inputs:
47            inputs_item = AudioSceneInput.from_dict(inputs_item_data)
48
49            inputs.append(inputs_item)
50
51        audio_scene = cls(
52            inputs=inputs,
53        )
54
55        return audio_scene

14@_attrs_define
15class AudioSceneInput:
16    """
17    Attributes:
18        input_id (str):
19        volume (float | None | Unset): (**default=`1.0`**) float in `[0, 2]` range representing input volume
20    """
21
22    input_id: str
23    volume: float | None | Unset = UNSET
24
25    def to_dict(self) -> dict[str, Any]:
26        input_id = self.input_id
27
28        volume: float | None | Unset
29        if isinstance(self.volume, Unset):
30            volume = UNSET
31        else:
32            volume = self.volume
33
34        field_dict: dict[str, Any] = {}
35
36        field_dict.update({
37            "input_id": input_id,
38        })
39        if volume is not UNSET:
40            field_dict["volume"] = volume
41
42        return field_dict
43
44    @classmethod
45    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
46        d = dict(src_dict)
47        input_id = d.pop("input_id")
48
49        def _parse_volume(data: object) -> float | None | Unset:
50            if data is None:
51                return data
52            if isinstance(data, Unset):
53                return data
54            return cast(float | None | Unset, data)
55
56        volume = _parse_volume(d.pop("volume", UNSET))
57
58        audio_scene_input = cls(
59            input_id=input_id,
60            volume=volume,
61        )
62
63        return audio_scene_input

13@_attrs_define
14class AverageAndMaxBitrate:
15    """
16    Attributes:
17        average_bitrate (int): Average bitrate measured in bits/second. Encoder will try to keep the bitrate around the
18            provided average,
19            but may temporarily increase it to the provided max bitrate.
20        max_bitrate (int): Max bitrate measured in bits/second.
21    """
22
23    average_bitrate: int
24    max_bitrate: int
25    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
26
27    def to_dict(self) -> dict[str, Any]:
28        average_bitrate = self.average_bitrate
29
30        max_bitrate = self.max_bitrate
31
32        field_dict: dict[str, Any] = {}
33        field_dict.update(self.additional_properties)
34        field_dict.update({
35            "average_bitrate": average_bitrate,
36            "max_bitrate": max_bitrate,
37        })
38
39        return field_dict
40
41    @classmethod
42    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
43        d = dict(src_dict)
44        average_bitrate = d.pop("average_bitrate")
45
46        max_bitrate = d.pop("max_bitrate")
47
48        average_and_max_bitrate = cls(
49            average_bitrate=average_bitrate,
50            max_bitrate=max_bitrate,
51        )
52
53        average_and_max_bitrate.additional_properties = d
54        return average_and_max_bitrate
55
56    @property
57    def additional_keys(self) -> list[str]:
58        return list(self.additional_properties.keys())
59
60    def __getitem__(self, key: str) -> Any:
61        return self.additional_properties[key]
62
63    def __setitem__(self, key: str, value: Any) -> None:
64        self.additional_properties[key] = value
65
66    def __delitem__(self, key: str) -> None:
67        del self.additional_properties[key]
68
69    def __contains__(self, key: str) -> bool:
70        return key in self.additional_properties

 14@_attrs_define
 15class BoxShadow:
 16    """
 17    Attributes:
 18        offset_x (float | None | Unset):
 19        offset_y (float | None | Unset):
 20        color (None | str | Unset):
 21        blur_radius (float | None | Unset):
 22    """
 23
 24    offset_x: float | None | Unset = UNSET
 25    offset_y: float | None | Unset = UNSET
 26    color: None | str | Unset = UNSET
 27    blur_radius: float | None | Unset = UNSET
 28
 29    def to_dict(self) -> dict[str, Any]:
 30        offset_x: float | None | Unset
 31        if isinstance(self.offset_x, Unset):
 32            offset_x = UNSET
 33        else:
 34            offset_x = self.offset_x
 35
 36        offset_y: float | None | Unset
 37        if isinstance(self.offset_y, Unset):
 38            offset_y = UNSET
 39        else:
 40            offset_y = self.offset_y
 41
 42        color: None | str | Unset
 43        if isinstance(self.color, Unset):
 44            color = UNSET
 45        else:
 46            color = self.color
 47
 48        blur_radius: float | None | Unset
 49        if isinstance(self.blur_radius, Unset):
 50            blur_radius = UNSET
 51        else:
 52            blur_radius = self.blur_radius
 53
 54        field_dict: dict[str, Any] = {}
 55
 56        field_dict.update({})
 57        if offset_x is not UNSET:
 58            field_dict["offset_x"] = offset_x
 59        if offset_y is not UNSET:
 60            field_dict["offset_y"] = offset_y
 61        if color is not UNSET:
 62            field_dict["color"] = color
 63        if blur_radius is not UNSET:
 64            field_dict["blur_radius"] = blur_radius
 65
 66        return field_dict
 67
 68    @classmethod
 69    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
 70        d = dict(src_dict)
 71
 72        def _parse_offset_x(data: object) -> float | None | Unset:
 73            if data is None:
 74                return data
 75            if isinstance(data, Unset):
 76                return data
 77            return cast(float | None | Unset, data)
 78
 79        offset_x = _parse_offset_x(d.pop("offset_x", UNSET))
 80
 81        def _parse_offset_y(data: object) -> float | None | Unset:
 82            if data is None:
 83                return data
 84            if isinstance(data, Unset):
 85                return data
 86            return cast(float | None | Unset, data)
 87
 88        offset_y = _parse_offset_y(d.pop("offset_y", UNSET))
 89
 90        def _parse_color(data: object) -> None | str | Unset:
 91            if data is None:
 92                return data
 93            if isinstance(data, Unset):
 94                return data
 95            return cast(None | str | Unset, data)
 96
 97        color = _parse_color(d.pop("color", UNSET))
 98
 99        def _parse_blur_radius(data: object) -> float | None | Unset:
100            if data is None:
101                return data
102            if isinstance(data, Unset):
103                return data
104            return cast(float | None | Unset, data)
105
106        blur_radius = _parse_blur_radius(d.pop("blur_radius", UNSET))
107
108        box_shadow = cls(
109            offset_x=offset_x,
110            offset_y=offset_y,
111            color=color,
112            blur_radius=blur_radius,
113        )
114
115        return box_shadow

13@_attrs_define
14class CompositionCreatedResponse:
15    """
16    Attributes:
17        composition_id (str):
18        api_url (str):
19    """
20
21    composition_id: str
22    api_url: str
23    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
24
25    def to_dict(self) -> dict[str, Any]:
26        composition_id = self.composition_id
27
28        api_url = self.api_url
29
30        field_dict: dict[str, Any] = {}
31        field_dict.update(self.additional_properties)
32        field_dict.update({
33            "composition_id": composition_id,
34            "api_url": api_url,
35        })
36
37        return field_dict
38
39    @classmethod
40    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
41        d = dict(src_dict)
42        composition_id = d.pop("composition_id")
43
44        api_url = d.pop("api_url")
45
46        composition_created_response = cls(
47            composition_id=composition_id,
48            api_url=api_url,
49        )
50
51        composition_created_response.additional_properties = d
52        return composition_created_response
53
54    @property
55    def additional_keys(self) -> list[str]:
56        return list(self.additional_properties.keys())
57
58    def __getitem__(self, key: str) -> Any:
59        return self.additional_properties[key]
60
61    def __setitem__(self, key: str, value: Any) -> None:
62        self.additional_properties[key] = value
63
64    def __delitem__(self, key: str) -> None:
65        del self.additional_properties[key]
66
67    def __contains__(self, key: str) -> bool:
68        return key in self.additional_properties

14@_attrs_define
15class CreateCompositionRequest:
16    """
17    Attributes:
18        autostart (bool | Unset): If true, outputs will immediately start producing audio and video.
19            If false, call `POST /api/composition/{composition_id}/start` to start the composition. Default: True.
20        cleanup_without_inputs (bool | Unset): If true (default), the composition will be cleaned up after 5 minutes
21            when all **inputs**
22            have zero bitrate, regardless of output bitrate. This prevents circular liveness when
23            composition output is sent to a stream.
24            If false, cleanup only triggers when both inputs and outputs have zero bitrate. Default: True.
25    """
26
27    autostart: bool | Unset = True
28    cleanup_without_inputs: bool | Unset = True
29
30    def to_dict(self) -> dict[str, Any]:
31        autostart = self.autostart
32
33        cleanup_without_inputs = self.cleanup_without_inputs
34
35        field_dict: dict[str, Any] = {}
36
37        field_dict.update({})
38        if autostart is not UNSET:
39            field_dict["autostart"] = autostart
40        if cleanup_without_inputs is not UNSET:
41            field_dict["cleanup_without_inputs"] = cleanup_without_inputs
42
43        return field_dict
44
45    @classmethod
46    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
47        d = dict(src_dict)
48        autostart = d.pop("autostart", UNSET)
49
50        cleanup_without_inputs = d.pop("cleanup_without_inputs", UNSET)
51
52        create_composition_request = cls(
53            autostart=autostart,
54            cleanup_without_inputs=cleanup_without_inputs,
55        )
56
57        return create_composition_request

17@_attrs_define
18class EasingFunctionBounce:
19    """
20    Attributes:
21        function_name (EasingFunctionBounceFunctionName):
22    """
23
24    function_name: EasingFunctionBounceFunctionName
25    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
26
27    def to_dict(self) -> dict[str, Any]:
28        function_name = self.function_name.value
29
30        field_dict: dict[str, Any] = {}
31        field_dict.update(self.additional_properties)
32        field_dict.update({
33            "function_name": function_name,
34        })
35
36        return field_dict
37
38    @classmethod
39    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
40        d = dict(src_dict)
41        function_name = EasingFunctionBounceFunctionName(d.pop("function_name"))
42
43        easing_function_bounce = cls(
44            function_name=function_name,
45        )
46
47        easing_function_bounce.additional_properties = d
48        return easing_function_bounce
49
50    @property
51    def additional_keys(self) -> list[str]:
52        return list(self.additional_properties.keys())
53
54    def __getitem__(self, key: str) -> Any:
55        return self.additional_properties[key]
56
57    def __setitem__(self, key: str, value: Any) -> None:
58        self.additional_properties[key] = value
59
60    def __delitem__(self, key: str) -> None:
61        del self.additional_properties[key]
62
63    def __contains__(self, key: str) -> bool:
64        return key in self.additional_properties

 5class EasingFunctionBounceFunctionName(str, Enum):
 6    """None"""
 7
 8    BOUNCE = "bounce"
 9
10    def __str__(self) -> str:
11        return str(self.value)

17@_attrs_define
18class EasingFunctionCubicBezier:
19    """
20    Attributes:
21        points (list[float]):
22        function_name (EasingFunctionCubicBezierFunctionName):
23    """
24
25    points: list[float]
26    function_name: EasingFunctionCubicBezierFunctionName
27    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
28
29    def to_dict(self) -> dict[str, Any]:
30        points = self.points
31
32        function_name = self.function_name.value
33
34        field_dict: dict[str, Any] = {}
35        field_dict.update(self.additional_properties)
36        field_dict.update({
37            "points": points,
38            "function_name": function_name,
39        })
40
41        return field_dict
42
43    @classmethod
44    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
45        d = dict(src_dict)
46        points = cast(list[float], d.pop("points"))
47
48        function_name = EasingFunctionCubicBezierFunctionName(d.pop("function_name"))
49
50        easing_function_cubic_bezier = cls(
51            points=points,
52            function_name=function_name,
53        )
54
55        easing_function_cubic_bezier.additional_properties = d
56        return easing_function_cubic_bezier
57
58    @property
59    def additional_keys(self) -> list[str]:
60        return list(self.additional_properties.keys())
61
62    def __getitem__(self, key: str) -> Any:
63        return self.additional_properties[key]
64
65    def __setitem__(self, key: str, value: Any) -> None:
66        self.additional_properties[key] = value
67
68    def __delitem__(self, key: str) -> None:
69        del self.additional_properties[key]
70
71    def __contains__(self, key: str) -> bool:
72        return key in self.additional_properties