1use std::collections::BTreeMap;
10
11use alpha2_model::{
12 Animated, Composition, Easing, EffectValue, LayoutNode, MediaSource, Rgba, TextShadow,
13 TextStroke, Track,
14};
15use serde::{Deserialize, Serialize};
16
17pub const COMPOSE_VERSION: u32 = 1;
19
20#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
22#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
23#[serde(deny_unknown_fields)]
24pub struct VideoSpec {
25 #[serde(rename = "$schema", default, skip_serializing_if = "Option::is_none")]
28 pub schema: Option<String>,
29 #[serde(default = "compose_version")]
31 #[cfg_attr(feature = "schema", schemars(extend("const" = COMPOSE_VERSION)))]
32 pub compose_version: u32,
33 #[serde(default, skip_serializing_if = "Option::is_none")]
35 pub name: Option<String>,
36 #[serde(default)]
38 pub canvas: Canvas,
39 #[serde(default)]
41 pub theme: ThemeChoice,
42 pub body: Node,
45 #[serde(default, skip_serializing_if = "Vec::is_empty")]
48 pub overlays: Vec<Node>,
49 #[serde(default, skip_serializing_if = "Vec::is_empty")]
51 pub audio: Vec<Node>,
52 #[serde(default, skip_serializing_if = "Option::is_none")]
54 pub duration: Option<f64>,
55 #[serde(default, skip_serializing_if = "Option::is_none")]
58 pub loudness: Option<Loudness>,
59}
60
61const fn compose_version() -> u32 {
62 COMPOSE_VERSION
63}
64
65#[derive(Clone, Debug, PartialEq, Serialize)]
67#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
68#[serde(untagged)]
69pub enum Canvas {
70 Preset(String),
73 Custom(CustomCanvas),
75}
76
77impl Default for Canvas {
78 fn default() -> Self {
79 Self::Preset("youtube-1080p".to_owned())
80 }
81}
82
83#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
85#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
86#[serde(deny_unknown_fields)]
87pub struct CustomCanvas {
88 #[serde(default, skip_serializing_if = "Option::is_none")]
90 pub preset: Option<String>,
91 #[serde(default, skip_serializing_if = "Option::is_none")]
93 pub width: Option<u32>,
94 #[serde(default, skip_serializing_if = "Option::is_none")]
96 pub height: Option<u32>,
97 #[serde(default, skip_serializing_if = "Option::is_none")]
100 pub frame_rate: Option<FrameRateChoice>,
101 #[serde(default, skip_serializing_if = "Option::is_none")]
103 pub background: Option<Rgba>,
104}
105
106#[derive(Clone, Copy, Debug, PartialEq, Serialize)]
108#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
109#[serde(untagged)]
110pub enum FrameRateChoice {
111 Number(f64),
113 Exact(alpha2_time::FrameRate),
115}
116
117#[derive(Clone, Debug, PartialEq, Serialize)]
119#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
120#[serde(untagged)]
121pub enum ThemeChoice {
122 Named(String),
124 Custom(Box<Theme>),
126}
127
128impl Default for ThemeChoice {
129 fn default() -> Self {
130 Self::Named("clean-dark".to_owned())
131 }
132}
133
134#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
137#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
138#[serde(deny_unknown_fields)]
139pub struct Theme {
140 #[serde(default, skip_serializing_if = "Option::is_none")]
142 pub base: Option<String>,
143 #[serde(default, skip_serializing_if = "Option::is_none")]
146 pub font_family: Option<String>,
147 #[serde(default, skip_serializing_if = "Option::is_none")]
149 pub text: Option<Rgba>,
150 #[serde(default, skip_serializing_if = "Option::is_none")]
152 pub background: Option<Rgba>,
153 #[serde(default, skip_serializing_if = "Option::is_none")]
155 pub surface: Option<Rgba>,
156 #[serde(default, skip_serializing_if = "Option::is_none")]
158 pub panel: Option<Rgba>,
159 #[serde(default, skip_serializing_if = "Option::is_none")]
161 pub accent: Option<Rgba>,
162 #[serde(default, skip_serializing_if = "Option::is_none")]
164 pub title_size: Option<f32>,
165 #[serde(default, skip_serializing_if = "Option::is_none")]
167 pub subtitle_size: Option<f32>,
168 #[serde(default, skip_serializing_if = "Option::is_none")]
170 pub body_size: Option<f32>,
171 #[serde(default, skip_serializing_if = "Option::is_none")]
173 pub caption_size: Option<f32>,
174 #[serde(default, skip_serializing_if = "Option::is_none")]
176 pub label_size: Option<f32>,
177 #[serde(default, skip_serializing_if = "Option::is_none")]
179 pub margin: Option<f32>,
180 #[serde(default, skip_serializing_if = "Option::is_none")]
182 pub transition: Option<Transition>,
183 #[serde(default, skip_serializing_if = "Option::is_none")]
185 pub still_seconds: Option<f64>,
186 #[serde(default, skip_serializing_if = "Option::is_none")]
188 pub text_seconds: Option<f64>,
189 #[serde(default, skip_serializing_if = "Option::is_none")]
191 pub fade_seconds: Option<f64>,
192}
193
194#[derive(Clone, Copy, Debug, PartialEq, Serialize)]
196#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
197#[serde(untagged)]
198pub enum Loudness {
199 Lufs(f64),
201 Target(crate::LoudnessTarget),
203}
204
205#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
207#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
208#[serde(deny_unknown_fields)]
209pub struct Transition {
210 #[serde(rename = "type")]
213 pub kind: String,
214 pub duration: f64,
216 #[serde(default, skip_serializing_if = "Option::is_none")]
218 pub easing: Option<Easing>,
219 #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
221 pub params: BTreeMap<String, Animated<EffectValue>>,
222 #[serde(default, skip_serializing_if = "Option::is_none")]
224 pub version: Option<u32>,
225}
226
227#[derive(Clone, Debug, PartialEq, Serialize)]
229#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
230#[serde(untagged)]
231pub enum TransitionChoice {
232 Named(String),
235 Given(Transition),
237}
238
239#[derive(Clone, Copy, Debug, PartialEq, Serialize)]
241#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
242#[serde(untagged)]
243pub enum Inset {
244 Uniform(f32),
246 Sides([f32; 4]),
248}
249
250#[derive(Clone, Copy, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
252#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
253#[serde(rename_all = "snake_case")]
254pub enum Fit {
255 #[default]
257 Contain,
258 Cover,
260 Fill,
262 None,
264}
265
266#[derive(Clone, Copy, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
268#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
269#[serde(rename_all = "kebab-case")]
270pub enum Align {
271 #[default]
273 Center,
274 Top,
276 Bottom,
278 Left,
280 Right,
282 TopLeft,
284 TopRight,
286 BottomLeft,
288 BottomRight,
290}
291
292#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
294#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
295#[serde(rename_all = "snake_case")]
296pub enum FileKind {
297 Video,
299 Image,
301 Audio,
303}
304
305#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
307#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
308#[serde(rename_all = "snake_case")]
309pub enum WhenShort {
310 Freeze,
312 Loop,
314 Stretch,
316 Blank,
318 Error,
320}
321
322#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
324#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
325#[serde(rename_all = "snake_case")]
326pub enum WhenLong {
327 Trim,
329 Stretch,
331 Error,
333}
334
335#[derive(Clone, Debug, PartialEq, Serialize)]
337#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
338#[serde(tag = "type", rename_all = "snake_case", deny_unknown_fields)]
339pub enum Node {
340 Sequence(Sequence),
342 Stack(Stack),
344 Grid(Grid),
346 Media(Media),
348 Text(Text),
350 Color(ColorFill),
352 Captions(Captions),
354 Layout(Layout),
356 Audio(Audio),
358 Raw(Raw),
360 Slideshow(Slideshow),
362 CaptionedVideo(CaptionedVideo),
364 MusicBed(MusicBed),
366 Counter(Counter),
368 Group(Group),
371 Shape(Shape),
373 Matte(Matte),
375 Mask(Mask),
377 Box(BoxNode),
379}
380
381#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
389#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
390#[serde(deny_unknown_fields)]
391pub struct Group {
392 #[serde(default, skip_serializing_if = "Option::is_none")]
394 pub id: Option<String>,
395 pub children: Vec<Node>,
397 #[serde(default, skip_serializing_if = "Option::is_none")]
399 pub at: Option<f64>,
400 #[serde(default, skip_serializing_if = "Option::is_none")]
402 pub duration: Option<f64>,
403 #[serde(default, skip_serializing_if = "Option::is_none")]
405 pub inset: Option<Inset>,
406 #[serde(default, skip_serializing_if = "Option::is_none")]
408 pub opacity: Option<Anim<f32>>,
409 #[serde(default, skip_serializing_if = "Option::is_none")]
411 pub blend: Option<alpha2_model::ClipBlendMode>,
412 #[serde(default, skip_serializing_if = "Vec::is_empty")]
414 pub effects: Vec<EffectUse>,
415 #[serde(default, skip_serializing_if = "Option::is_none")]
417 pub transform: Option<GroupTransform>,
418 #[serde(default, skip_serializing_if = "Option::is_none")]
420 pub enter: Option<Motion>,
421 #[serde(default, skip_serializing_if = "Option::is_none")]
423 pub exit: Option<Motion>,
424}
425
426#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
430#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
431pub struct EffectUse {
432 pub effect: String,
434 #[serde(default, skip_serializing_if = "Option::is_none")]
436 pub version: Option<u32>,
437 #[serde(flatten)]
439 pub params: BTreeMap<String, serde_json::Value>,
440}
441
442#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
444#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
445#[serde(deny_unknown_fields)]
446pub struct GroupTransform {
447 #[serde(default, skip_serializing_if = "Option::is_none")]
449 pub position: Option<Anim<[f32; 2]>>,
450 #[serde(default, skip_serializing_if = "Option::is_none")]
452 pub scale: Option<Anim<f32>>,
453 #[serde(default, skip_serializing_if = "Option::is_none")]
455 pub rotation: Option<Anim<f32>>,
456 #[serde(default, skip_serializing_if = "Option::is_none")]
459 pub anchor: Option<[f32; 2]>,
460}
461
462#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
464#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
465#[serde(deny_unknown_fields)]
466pub struct Sequence {
467 #[serde(default, skip_serializing_if = "Option::is_none")]
469 pub id: Option<String>,
470 pub children: Vec<Node>,
472 #[serde(default, skip_serializing_if = "Option::is_none")]
477 pub transition: Option<TransitionChoice>,
478 #[serde(default, skip_serializing_if = "Option::is_none")]
480 pub at: Option<f64>,
481 #[serde(default, skip_serializing_if = "Option::is_none")]
483 pub duration: Option<f64>,
484 #[serde(default, skip_serializing_if = "Option::is_none")]
486 pub enter: Option<Motion>,
487 #[serde(default, skip_serializing_if = "Option::is_none")]
489 pub exit: Option<Motion>,
490}
491
492#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
494#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
495#[serde(deny_unknown_fields)]
496pub struct Stack {
497 #[serde(default, skip_serializing_if = "Option::is_none")]
499 pub id: Option<String>,
500 pub children: Vec<Node>,
502 #[serde(default, skip_serializing_if = "Option::is_none")]
504 pub at: Option<f64>,
505 #[serde(default, skip_serializing_if = "Option::is_none")]
507 pub duration: Option<f64>,
508 #[serde(default, skip_serializing_if = "Option::is_none")]
510 pub inset: Option<Inset>,
511 #[serde(default, skip_serializing_if = "Option::is_none")]
513 pub enter: Option<Motion>,
514 #[serde(default, skip_serializing_if = "Option::is_none")]
516 pub exit: Option<Motion>,
517 #[serde(default, skip_serializing_if = "Option::is_none")]
521 pub stagger: Option<f64>,
522}
523
524#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
526#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
527#[serde(deny_unknown_fields)]
528pub struct Grid {
529 #[serde(default, skip_serializing_if = "Option::is_none")]
531 pub id: Option<String>,
532 pub children: Vec<Node>,
534 #[serde(default, skip_serializing_if = "Option::is_none")]
536 pub columns: Option<u32>,
537 #[serde(default)]
539 pub gap: f32,
540 #[serde(default)]
543 pub length: GridLength,
544 #[serde(default, skip_serializing_if = "Option::is_none")]
546 pub at: Option<f64>,
547 #[serde(default, skip_serializing_if = "Option::is_none")]
549 pub duration: Option<f64>,
550 #[serde(default, skip_serializing_if = "Option::is_none")]
552 pub inset: Option<Inset>,
553 #[serde(default, skip_serializing_if = "Option::is_none")]
555 pub enter: Option<Motion>,
556 #[serde(default, skip_serializing_if = "Option::is_none")]
558 pub exit: Option<Motion>,
559 #[serde(default, skip_serializing_if = "Option::is_none")]
563 pub stagger: Option<f64>,
564}
565
566#[derive(Clone, Copy, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
568#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
569#[serde(rename_all = "snake_case")]
570pub enum GridLength {
571 #[default]
573 Shortest,
574 LongestFreeze,
576 LongestLoop,
578}
579
580#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
582#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
583#[serde(deny_unknown_fields)]
584pub struct Media {
585 #[serde(default, skip_serializing_if = "Option::is_none")]
587 pub id: Option<String>,
588 pub path: String,
590 #[serde(default, skip_serializing_if = "Option::is_none")]
592 pub kind: Option<FileKind>,
593 #[serde(default, skip_serializing_if = "Option::is_none")]
595 pub trim_start: Option<f64>,
596 #[serde(default, skip_serializing_if = "Option::is_none")]
598 pub trim_end: Option<f64>,
599 #[serde(default, skip_serializing_if = "Option::is_none")]
602 pub speed: Option<f64>,
603 #[serde(default, skip_serializing_if = "Option::is_none")]
606 pub preserve_pitch: Option<bool>,
607 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
609 pub r#loop: bool,
610 #[serde(default, skip_serializing_if = "Option::is_none")]
613 pub when_short: Option<WhenShort>,
614 #[serde(default, skip_serializing_if = "Option::is_none")]
616 pub when_long: Option<WhenLong>,
617 #[serde(default, skip_serializing_if = "Option::is_none")]
619 pub volume: Option<f32>,
620 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
622 pub muted: bool,
623 #[serde(default, skip_serializing_if = "Option::is_none")]
625 pub opacity: Option<f32>,
626 #[serde(default, skip_serializing_if = "Option::is_none")]
628 pub fade_in: Option<f64>,
629 #[serde(default, skip_serializing_if = "Option::is_none")]
631 pub fade_out: Option<f64>,
632 #[serde(default, skip_serializing_if = "Option::is_none")]
635 pub zoom: Option<Anim<f32>>,
636 #[serde(default, skip_serializing_if = "Option::is_none")]
638 pub blur: Option<f32>,
639 #[serde(default, skip_serializing_if = "Option::is_none")]
641 pub label: Option<String>,
642 #[serde(default, skip_serializing_if = "Option::is_none")]
644 pub at: Option<f64>,
645 #[serde(default, skip_serializing_if = "Option::is_none")]
647 pub duration: Option<f64>,
648 #[serde(default, skip_serializing_if = "Option::is_none")]
650 pub inset: Option<Inset>,
651 #[serde(default, skip_serializing_if = "Option::is_none")]
653 pub fit: Option<Fit>,
654 #[serde(default, skip_serializing_if = "Option::is_none")]
656 pub align: Option<Align>,
657 #[serde(default, skip_serializing_if = "Option::is_none")]
659 pub enter: Option<Motion>,
660 #[serde(default, skip_serializing_if = "Option::is_none")]
662 pub exit: Option<Motion>,
663}
664
665impl Media {
666 #[must_use]
668 pub fn new(path: impl Into<String>) -> Self {
669 Self {
670 id: None,
671 path: path.into(),
672 kind: None,
673 trim_start: None,
674 trim_end: None,
675 speed: None,
676 preserve_pitch: None,
677 r#loop: false,
678 volume: None,
679 muted: false,
680 opacity: None,
681 fade_in: None,
682 fade_out: None,
683 zoom: None,
684 when_short: None,
685 when_long: None,
686 blur: None,
687 label: None,
688 at: None,
689 duration: None,
690 inset: None,
691 fit: None,
692 align: None,
693 enter: None,
694 exit: None,
695 }
696 }
697}
698
699#[derive(Clone, Debug, PartialEq, Serialize)]
701#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
702#[serde(untagged)]
703pub enum MediaItem {
704 Path(String),
706 Node(Box<Node>),
708}
709
710#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
712#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
713#[serde(deny_unknown_fields)]
714pub struct Text {
715 #[serde(default, skip_serializing_if = "Option::is_none")]
717 pub id: Option<String>,
718 pub text: String,
720 #[serde(default)]
722 pub style: TextRole,
723 #[serde(default, skip_serializing_if = "Option::is_none")]
725 pub font_size: Option<Size>,
726 #[serde(default, skip_serializing_if = "Option::is_none")]
728 pub font_family: Option<String>,
729 #[serde(default, skip_serializing_if = "Option::is_none")]
731 pub color: Option<SolidColor>,
732 #[serde(default, skip_serializing_if = "Option::is_none")]
734 pub background: Option<SolidColor>,
735 #[serde(default, skip_serializing_if = "Vec::is_empty")]
738 pub strokes: Vec<TextStroke>,
739 #[serde(default, skip_serializing_if = "Vec::is_empty")]
742 pub shadows: Vec<TextShadow>,
743 #[serde(default, skip_serializing_if = "Option::is_none")]
746 pub max_lines: Option<u32>,
747 #[serde(default, skip_serializing_if = "Option::is_none")]
751 pub fit: Option<TextFit>,
752 #[serde(default, skip_serializing_if = "Option::is_none")]
755 pub ellipsis: Option<Ellipsis>,
756 #[serde(default, skip_serializing_if = "Option::is_none")]
758 pub opacity: Option<f32>,
759 #[serde(default, skip_serializing_if = "Option::is_none")]
761 pub fade: Option<f64>,
762 #[serde(default, skip_serializing_if = "Option::is_none")]
764 pub at: Option<f64>,
765 #[serde(default, skip_serializing_if = "Option::is_none")]
767 pub duration: Option<f64>,
768 #[serde(default, skip_serializing_if = "Option::is_none")]
770 pub inset: Option<Inset>,
771 #[serde(default, skip_serializing_if = "Option::is_none")]
773 pub align: Option<Align>,
774 #[serde(default, skip_serializing_if = "Option::is_none")]
776 pub enter: Option<Motion>,
777 #[serde(default, skip_serializing_if = "Option::is_none")]
779 pub exit: Option<Motion>,
780 #[serde(default, skip_serializing_if = "Option::is_none")]
782 pub reveal: Option<Reveal>,
783}
784
785#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize)]
787#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
788#[serde(deny_unknown_fields)]
789pub struct TextFit {
790 pub min: f32,
792 #[serde(default, skip_serializing_if = "Option::is_none")]
794 pub max: Option<f32>,
795}
796
797#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
799#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
800#[serde(untagged)]
801pub enum Ellipsis {
802 Shown(bool),
804 Text(String),
806}
807
808#[derive(Clone, Copy, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
810#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
811#[serde(rename_all = "snake_case")]
812pub enum TextRole {
813 Title,
815 Subtitle,
817 #[default]
819 Body,
820 Label,
822}
823
824#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
828#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
829#[serde(deny_unknown_fields)]
830pub struct Shape {
831 #[serde(default, skip_serializing_if = "Option::is_none")]
833 pub id: Option<String>,
834 pub shapes: Vec<Geometry>,
836 #[serde(default, skip_serializing_if = "Option::is_none")]
839 pub fill: Option<PaintChoice>,
840 #[serde(default, skip_serializing_if = "Option::is_none")]
842 pub stroke: Option<Stroke>,
843 #[serde(default, skip_serializing_if = "Option::is_none")]
846 pub trim: Option<Trim>,
847 #[serde(default, skip_serializing_if = "Option::is_none")]
849 pub opacity: Option<f32>,
850 #[serde(default, skip_serializing_if = "Option::is_none")]
852 pub at: Option<f64>,
853 #[serde(default, skip_serializing_if = "Option::is_none")]
855 pub duration: Option<f64>,
856 #[serde(default, skip_serializing_if = "Option::is_none")]
858 pub inset: Option<Inset>,
859 #[serde(default, skip_serializing_if = "Option::is_none")]
861 pub enter: Option<Motion>,
862 #[serde(default, skip_serializing_if = "Option::is_none")]
864 pub exit: Option<Motion>,
865}
866
867#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
870#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
871#[serde(deny_unknown_fields)]
872pub struct Matte {
873 #[serde(default, skip_serializing_if = "Option::is_none")]
875 pub id: Option<String>,
876 pub content: Box<Node>,
878 pub by: Box<Node>,
880 #[serde(rename = "use", default, skip_serializing_if = "Option::is_none")]
882 pub uses: Option<MatteUse>,
883 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
885 pub invert: bool,
886 #[serde(default, skip_serializing_if = "Option::is_none")]
888 pub at: Option<f64>,
889 #[serde(default, skip_serializing_if = "Option::is_none")]
891 pub duration: Option<f64>,
892 #[serde(default, skip_serializing_if = "Option::is_none")]
894 pub inset: Option<Inset>,
895}
896
897#[derive(Clone, Copy, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
899#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
900#[serde(rename_all = "snake_case")]
901pub enum MatteUse {
902 #[default]
904 Alpha,
905 Luma,
907}
908
909#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
912#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
913#[serde(deny_unknown_fields)]
914pub struct Mask {
915 #[serde(default, skip_serializing_if = "Option::is_none")]
917 pub id: Option<String>,
918 pub content: Box<Node>,
920 pub shapes: Vec<MaskShape>,
922 #[serde(default, skip_serializing_if = "Option::is_none")]
924 pub at: Option<f64>,
925 #[serde(default, skip_serializing_if = "Option::is_none")]
927 pub duration: Option<f64>,
928 #[serde(default, skip_serializing_if = "Option::is_none")]
930 pub inset: Option<Inset>,
931}
932
933#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
935#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
936pub struct MaskShape {
937 #[serde(flatten)]
939 pub geometry: Geometry,
940 #[serde(default, skip_serializing_if = "Option::is_none")]
942 pub mode: Option<alpha2_model::MaskMode>,
943 #[serde(default, skip_serializing_if = "Option::is_none")]
945 pub feather: Option<Anim<f32>>,
946 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
948 pub invert: bool,
949}
950
951#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
960#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
961pub struct BoxNode {
962 #[serde(default, skip_serializing_if = "Option::is_none")]
964 pub id: Option<String>,
965 #[serde(default, skip_serializing_if = "Vec::is_empty")]
967 pub children: Vec<BoxChild>,
968 #[serde(default, skip_serializing_if = "Option::is_none")]
970 pub background: Option<PaintChoice>,
971 #[serde(default, skip_serializing_if = "Option::is_none")]
973 pub border: Option<BoxBorder>,
974 #[serde(default, skip_serializing_if = "Option::is_none")]
976 pub at: Option<f64>,
977 #[serde(default, skip_serializing_if = "Option::is_none")]
979 pub duration: Option<f64>,
980 #[serde(default, skip_serializing_if = "Option::is_none")]
982 pub inset: Option<Inset>,
983 #[serde(flatten)]
987 pub css: BTreeMap<String, serde_json::Value>,
988}
989
990#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
992#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
993#[serde(deny_unknown_fields)]
994pub struct BoxBorder {
995 pub width: LayoutSize,
997 pub paint: PaintChoice,
999}
1000
1001#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
1003#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1004#[serde(untagged)]
1005pub enum LayoutSize {
1006 Fraction(f32),
1008 Pixels(String),
1010}
1011
1012#[derive(Clone, Debug, PartialEq, Serialize)]
1015#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1016#[serde(untagged)]
1017pub enum BoxChild {
1018 Placed(PlacedChild),
1020 Plain(Node),
1022}
1023
1024#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
1026#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1027#[serde(deny_unknown_fields)]
1028pub struct PlacedChild {
1029 #[serde(rename = "box")]
1031 pub item: BTreeMap<String, serde_json::Value>,
1032 pub node: Node,
1034}
1035
1036impl BoxChild {
1037 #[must_use]
1039 pub const fn node(&self) -> &Node {
1040 match self {
1041 Self::Placed(placed) => &placed.node,
1042 Self::Plain(node) => node,
1043 }
1044 }
1045
1046 #[must_use]
1048 pub fn item(&self) -> BTreeMap<String, serde_json::Value> {
1049 match self {
1050 Self::Placed(placed) => placed.item.clone(),
1051 Self::Plain(_) => BTreeMap::new(),
1052 }
1053 }
1054}
1055
1056impl<'de> Deserialize<'de> for BoxChild {
1057 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1060 use serde::de::Error as _;
1061 let value = serde_json::Value::deserialize(deserializer)?;
1062 if value
1063 .as_object()
1064 .is_some_and(|object| object.contains_key("node"))
1065 {
1066 serde_json::from_value(value)
1067 .map(Self::Placed)
1068 .map_err(D::Error::custom)
1069 } else {
1070 Node::deserialize(value)
1071 .map(Self::Plain)
1072 .map_err(D::Error::custom)
1073 }
1074 }
1075}
1076
1077#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
1079#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1080#[serde(tag = "shape", rename_all = "snake_case", deny_unknown_fields)]
1081pub enum Geometry {
1082 Rect {
1084 #[serde(default, skip_serializing_if = "Option::is_none")]
1086 center: Option<Anim<[f32; 2]>>,
1087 #[serde(default, skip_serializing_if = "Option::is_none")]
1089 size: Option<Anim<[f32; 2]>>,
1090 #[serde(default, skip_serializing_if = "Option::is_none")]
1092 corner_radius: Option<Anim<f32>>,
1093 #[serde(default, skip_serializing_if = "Option::is_none")]
1095 rotation: Option<Anim<f32>>,
1096 },
1097 Ellipse {
1099 #[serde(default, skip_serializing_if = "Option::is_none")]
1101 center: Option<Anim<[f32; 2]>>,
1102 #[serde(default, skip_serializing_if = "Option::is_none")]
1104 size: Option<Anim<[f32; 2]>>,
1105 #[serde(default, skip_serializing_if = "Option::is_none")]
1107 rotation: Option<Anim<f32>>,
1108 },
1109 Polygon {
1111 #[serde(default, skip_serializing_if = "Option::is_none")]
1113 center: Option<Anim<[f32; 2]>>,
1114 points: u32,
1116 #[serde(default, skip_serializing_if = "Option::is_none")]
1118 radius: Option<Anim<f32>>,
1119 #[serde(default, skip_serializing_if = "Option::is_none")]
1121 roundness: Option<Anim<f32>>,
1122 #[serde(default, skip_serializing_if = "Option::is_none")]
1124 rotation: Option<Anim<f32>>,
1125 },
1126 Star {
1128 #[serde(default, skip_serializing_if = "Option::is_none")]
1130 center: Option<Anim<[f32; 2]>>,
1131 points: u32,
1133 #[serde(default, skip_serializing_if = "Option::is_none")]
1135 outer_radius: Option<Anim<f32>>,
1136 #[serde(default, skip_serializing_if = "Option::is_none")]
1138 inner_radius: Option<Anim<f32>>,
1139 #[serde(default, skip_serializing_if = "Option::is_none")]
1141 rotation: Option<Anim<f32>>,
1142 },
1143 Path {
1145 d: String,
1148 },
1149}
1150
1151#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
1153#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1154#[serde(untagged)]
1155pub enum PaintChoice {
1156 Theme(ThemeColor),
1158 Linear(LinearPaint),
1160 Radial(RadialPaint),
1162 Conic(ConicPaint),
1164 Color(Rgba),
1166}
1167
1168#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
1170#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1171#[serde(deny_unknown_fields)]
1172pub struct LinearPaint {
1173 pub linear: Gradient,
1175}
1176
1177#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
1179#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1180#[serde(deny_unknown_fields)]
1181pub struct RadialPaint {
1182 pub radial: Gradient,
1184}
1185
1186#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
1188#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1189#[serde(deny_unknown_fields)]
1190pub struct ConicPaint {
1191 pub conic: Gradient,
1193}
1194
1195pub const COMPOSE_SCHEMA_ID: &str = "https://alpha2.sh/schema/compose.v1.json";
1197
1198#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize)]
1200#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1201#[serde(untagged)]
1202pub enum Size {
1203 Pixels(f32),
1205 Theme(ThemeLength),
1207}
1208
1209#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize)]
1211#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1212#[serde(deny_unknown_fields)]
1213pub struct ThemeLength {
1214 #[serde(rename = "$theme")]
1216 pub token: LengthToken,
1217 #[serde(default, skip_serializing_if = "Option::is_none")]
1219 pub scale: Option<f32>,
1220}
1221
1222#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
1224#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1225#[serde(rename_all = "snake_case")]
1226pub enum LengthToken {
1227 Margin,
1229 TitleSize,
1231 SubtitleSize,
1233 BodySize,
1235 CaptionSize,
1237 LabelSize,
1239}
1240
1241#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize)]
1243#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1244#[serde(deny_unknown_fields)]
1245pub struct ThemeColor {
1246 #[serde(rename = "$theme")]
1248 pub token: ThemeToken,
1249 #[serde(default, skip_serializing_if = "Option::is_none")]
1251 pub alpha: Option<f32>,
1252}
1253
1254#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
1256#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1257#[serde(rename_all = "snake_case")]
1258pub enum ThemeToken {
1259 Text,
1261 Background,
1263 Surface,
1265 Panel,
1267 Accent,
1269}
1270
1271#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
1273#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1274#[serde(deny_unknown_fields)]
1275pub struct Gradient {
1276 pub stops: Vec<Stop>,
1278 #[serde(default, skip_serializing_if = "Option::is_none")]
1281 pub angle: Option<f32>,
1282 #[serde(default, skip_serializing_if = "Option::is_none")]
1284 pub center: Option<[f32; 2]>,
1285 #[serde(default, skip_serializing_if = "Option::is_none")]
1287 pub radius: Option<f32>,
1288}
1289
1290#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
1292#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1293#[serde(untagged)]
1294pub enum Stop {
1295 At(OffsetStop),
1297 Even(SolidColor),
1299}
1300
1301#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
1303#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1304#[serde(deny_unknown_fields)]
1305pub struct OffsetStop {
1306 pub color: SolidColor,
1308 pub offset: f32,
1310}
1311
1312#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize)]
1314#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1315#[serde(untagged)]
1316pub enum SolidColor {
1317 Theme(ThemeColor),
1319 Color(Rgba),
1321}
1322
1323#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
1325#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1326#[serde(deny_unknown_fields)]
1327pub struct Stroke {
1328 #[serde(default, skip_serializing_if = "Option::is_none")]
1330 pub paint: Option<PaintChoice>,
1331 pub width: Anim<f32>,
1333 #[serde(default, skip_serializing_if = "Vec::is_empty")]
1335 pub dash: Vec<f32>,
1336 #[serde(default, skip_serializing_if = "Option::is_none")]
1338 pub cap: Option<alpha2_model::LineCap>,
1339 #[serde(default, skip_serializing_if = "Option::is_none")]
1341 pub join: Option<alpha2_model::LineJoin>,
1342}
1343
1344#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
1346#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1347#[serde(deny_unknown_fields)]
1348pub struct Trim {
1349 #[serde(default, skip_serializing_if = "Option::is_none")]
1351 pub start: Option<Anim<f32>>,
1352 #[serde(default, skip_serializing_if = "Option::is_none")]
1354 pub end: Option<Anim<f32>>,
1355 #[serde(default, skip_serializing_if = "Option::is_none")]
1357 pub offset: Option<Anim<f32>>,
1358}
1359
1360#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
1362#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1363#[serde(deny_unknown_fields)]
1364pub struct ColorFill {
1365 #[serde(default, skip_serializing_if = "Option::is_none")]
1367 pub id: Option<String>,
1368 #[serde(default, skip_serializing_if = "Option::is_none")]
1370 pub color: Option<SolidColor>,
1371 #[serde(default, skip_serializing_if = "Option::is_none")]
1373 pub at: Option<f64>,
1374 #[serde(default, skip_serializing_if = "Option::is_none")]
1376 pub duration: Option<f64>,
1377 #[serde(default, skip_serializing_if = "Option::is_none")]
1379 pub inset: Option<Inset>,
1380 #[serde(default, skip_serializing_if = "Option::is_none")]
1382 pub enter: Option<Motion>,
1383 #[serde(default, skip_serializing_if = "Option::is_none")]
1385 pub exit: Option<Motion>,
1386}
1387
1388#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
1390#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1391#[cfg_attr(feature = "schema", schemars(rename = "CaptionsNode"))]
1392#[serde(deny_unknown_fields)]
1393pub struct Captions {
1394 #[serde(default, skip_serializing_if = "Option::is_none")]
1396 pub id: Option<String>,
1397 #[serde(default, skip_serializing_if = "Vec::is_empty")]
1399 pub cues: Vec<Cue>,
1400 #[serde(default, skip_serializing_if = "Vec::is_empty")]
1403 pub words: Vec<Cue>,
1404 #[serde(default, skip_serializing_if = "Option::is_none")]
1406 pub file: Option<String>,
1407 #[serde(default, skip_serializing_if = "Option::is_none")]
1409 pub srt: Option<String>,
1410 #[serde(default, skip_serializing_if = "Option::is_none")]
1412 pub vtt: Option<String>,
1413 #[serde(default)]
1415 pub style: CaptionStyle,
1416 #[serde(default, skip_serializing_if = "Option::is_none")]
1419 pub max_chars: Option<u32>,
1420 #[serde(default, skip_serializing_if = "Option::is_none")]
1422 pub font_size: Option<Size>,
1423 #[serde(default, skip_serializing_if = "Option::is_none")]
1425 pub color: Option<SolidColor>,
1426 #[serde(default, skip_serializing_if = "Option::is_none")]
1428 pub highlight: Option<SolidColor>,
1429 #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
1432 pub speakers: BTreeMap<String, SpeakerLook>,
1433 #[serde(default, skip_serializing_if = "Option::is_none")]
1436 pub position: Option<f32>,
1437 #[serde(default, skip_serializing_if = "Option::is_none")]
1439 pub at: Option<f64>,
1440 #[serde(default, skip_serializing_if = "Option::is_none")]
1442 pub duration: Option<f64>,
1443}
1444
1445#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
1447#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1448#[serde(deny_unknown_fields)]
1449pub struct Cue {
1450 pub start: f64,
1452 pub end: f64,
1454 pub text: String,
1456 #[serde(default, skip_serializing_if = "Option::is_none")]
1458 pub speaker: Option<String>,
1459}
1460
1461#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
1463#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1464#[serde(deny_unknown_fields)]
1465pub struct SpeakerLook {
1466 #[serde(default, skip_serializing_if = "Option::is_none")]
1468 pub color: Option<SolidColor>,
1469 #[serde(default, skip_serializing_if = "Option::is_none")]
1471 pub position: Option<alpha2_model::Vec2>,
1472}
1473
1474#[derive(Clone, Copy, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
1476#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1477#[serde(rename_all = "kebab-case")]
1478pub enum CaptionStyle {
1479 #[default]
1481 Outline,
1482 Boxed,
1484 BarBottom,
1487 BoldCenter,
1489 Bold,
1491 Karaoke,
1494 Pop,
1496}
1497
1498#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
1500#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1501#[serde(deny_unknown_fields)]
1502pub struct Layout {
1503 #[serde(default, skip_serializing_if = "Option::is_none")]
1505 pub id: Option<String>,
1506 pub root: Box<LayoutNode>,
1508 #[serde(default, skip_serializing_if = "Option::is_none")]
1510 pub at: Option<f64>,
1511 #[serde(default, skip_serializing_if = "Option::is_none")]
1513 pub duration: Option<f64>,
1514 #[serde(default, skip_serializing_if = "Option::is_none")]
1516 pub inset: Option<Inset>,
1517 #[serde(default, skip_serializing_if = "Option::is_none")]
1519 pub align: Option<Align>,
1520 #[serde(default, skip_serializing_if = "Option::is_none")]
1522 pub enter: Option<Motion>,
1523 #[serde(default, skip_serializing_if = "Option::is_none")]
1525 pub exit: Option<Motion>,
1526}
1527
1528#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
1530#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1531#[serde(deny_unknown_fields)]
1532pub struct Audio {
1533 #[serde(default, skip_serializing_if = "Option::is_none")]
1535 pub id: Option<String>,
1536 pub path: String,
1538 #[serde(default, skip_serializing_if = "Option::is_none")]
1540 pub trim_start: Option<f64>,
1541 #[serde(default, skip_serializing_if = "Option::is_none")]
1543 pub trim_end: Option<f64>,
1544 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
1546 pub r#loop: bool,
1547 #[serde(default, skip_serializing_if = "Option::is_none")]
1549 pub volume: Option<f32>,
1550 #[serde(default, skip_serializing_if = "Option::is_none")]
1552 pub fade_in: Option<f64>,
1553 #[serde(default, skip_serializing_if = "Option::is_none")]
1555 pub fade_out: Option<f64>,
1556 #[serde(default, skip_serializing_if = "Option::is_none")]
1558 pub duck_under: Option<String>,
1559 #[serde(default, skip_serializing_if = "Option::is_none")]
1561 pub duck_depth_db: Option<f32>,
1562 #[serde(default, skip_serializing_if = "Option::is_none")]
1564 pub at: Option<f64>,
1565 #[serde(default, skip_serializing_if = "Option::is_none")]
1567 pub duration: Option<f64>,
1568}
1569
1570#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
1572#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1573#[serde(deny_unknown_fields)]
1574pub struct Raw {
1575 #[serde(default, skip_serializing_if = "Vec::is_empty")]
1578 pub sources: Vec<MediaSource>,
1579 #[serde(default, skip_serializing_if = "Vec::is_empty")]
1581 pub tracks: Vec<Track>,
1582 #[serde(default, skip_serializing_if = "Vec::is_empty")]
1584 pub compositions: Vec<Composition>,
1585 #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
1587 pub assets: BTreeMap<String, String>,
1588}
1589
1590#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
1592#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1593#[serde(deny_unknown_fields)]
1594pub struct Slideshow {
1595 #[serde(default, skip_serializing_if = "Option::is_none")]
1597 pub id: Option<String>,
1598 pub items: Vec<MediaItem>,
1600 #[serde(default, skip_serializing_if = "Option::is_none")]
1603 pub seconds: Option<f64>,
1604 #[serde(default, skip_serializing_if = "Option::is_none")]
1606 pub fit_to: Option<String>,
1607 #[serde(default, skip_serializing_if = "Option::is_none")]
1609 pub transition: Option<TransitionChoice>,
1610 #[serde(default, skip_serializing_if = "Option::is_none")]
1613 pub ken_burns: Option<f32>,
1614 #[serde(default, skip_serializing_if = "Option::is_none")]
1616 pub fit: Option<Fit>,
1617 #[serde(default, skip_serializing_if = "Option::is_none")]
1619 pub at: Option<f64>,
1620}
1621
1622#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
1624#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1625#[serde(deny_unknown_fields)]
1626pub struct CaptionedVideo {
1627 #[serde(default, skip_serializing_if = "Option::is_none")]
1629 pub id: Option<String>,
1630 pub video: MediaItem,
1632 pub captions: Box<Captions>,
1634 #[serde(default, skip_serializing_if = "Option::is_none")]
1636 pub fit: Option<Fit>,
1637 #[serde(default, skip_serializing_if = "Option::is_none")]
1639 pub at: Option<f64>,
1640}
1641
1642#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
1644#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1645#[serde(deny_unknown_fields)]
1646pub struct MusicBed {
1647 #[serde(default, skip_serializing_if = "Option::is_none")]
1649 pub id: Option<String>,
1650 pub path: String,
1652 #[serde(default, skip_serializing_if = "Option::is_none")]
1654 pub volume: Option<f32>,
1655 #[serde(default, skip_serializing_if = "Option::is_none")]
1657 pub fade_in: Option<f64>,
1658 #[serde(default, skip_serializing_if = "Option::is_none")]
1660 pub fade_out: Option<f64>,
1661 #[serde(default, skip_serializing_if = "Option::is_none")]
1663 pub duck_under: Option<String>,
1664 #[serde(default, skip_serializing_if = "Option::is_none")]
1666 pub duck_depth_db: Option<f32>,
1667 #[serde(default = "yes")]
1669 pub r#loop: bool,
1670 #[serde(default, skip_serializing_if = "Option::is_none")]
1672 pub at: Option<f64>,
1673 #[serde(default, skip_serializing_if = "Option::is_none")]
1675 pub duration: Option<f64>,
1676}
1677
1678const fn yes() -> bool {
1679 true
1680}
1681
1682#[derive(Clone, Debug, PartialEq, Serialize)]
1685#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1686#[serde(untagged)]
1687pub enum EasingChoice {
1688 Named(String),
1690 Curve(Easing),
1692}
1693
1694#[derive(Clone, Debug, PartialEq, Serialize)]
1697#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1698#[serde(untagged)]
1699pub enum Anim<T> {
1700 Ramp(Ramp<T>),
1702 Keys(Keys<T>),
1704 Value(T),
1706}
1707
1708impl<'de, T: serde::de::DeserializeOwned> Deserialize<'de> for Anim<T> {
1709 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1712 use serde::de::Error as _;
1713 let value = serde_json::Value::deserialize(deserializer)?;
1714 let object = value.as_object();
1715 if object.is_some_and(|object| object.contains_key("keys")) {
1716 serde_json::from_value(value).map(Anim::Keys)
1717 } else if object.is_some_and(|object| object.contains_key("from")) {
1718 serde_json::from_value(value).map(Anim::Ramp)
1719 } else if value.is_array() && !accepts_array::<T>() {
1720 return Err(D::Error::custom(
1721 "expected a value, `{from, to}` or `{keys}`, not an array",
1722 ));
1723 } else {
1724 serde_json::from_value(value).map(Anim::Value)
1725 }
1726 .map_err(D::Error::custom)
1727 }
1728}
1729
1730fn accepts_array<T: serde::de::DeserializeOwned>() -> bool {
1732 serde_json::from_value::<T>(serde_json::json!([0, 0])).is_ok()
1733 || serde_json::from_value::<T>(serde_json::json!([0, 0, 0, 0])).is_ok()
1734}
1735
1736#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
1738#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1739#[serde(deny_unknown_fields)]
1740pub struct Ramp<T> {
1741 pub from: T,
1743 pub to: T,
1745 #[serde(default, skip_serializing_if = "Option::is_none")]
1747 pub ease: Option<EasingChoice>,
1748 #[serde(default, skip_serializing_if = "Option::is_none")]
1750 pub at: Option<f64>,
1751 #[serde(default, skip_serializing_if = "Option::is_none")]
1753 pub duration: Option<f64>,
1754}
1755
1756#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
1758#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1759#[serde(deny_unknown_fields)]
1760pub struct Keys<T> {
1761 pub keys: Vec<Key<T>>,
1763}
1764
1765#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
1767#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1768#[serde(deny_unknown_fields)]
1769pub struct Key<T> {
1770 pub t: f64,
1772 pub v: T,
1774 #[serde(default, skip_serializing_if = "Option::is_none")]
1776 pub ease: Option<EasingChoice>,
1777}
1778
1779#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
1781#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1782#[serde(deny_unknown_fields)]
1783pub struct Motion {
1784 #[serde(rename = "type")]
1788 pub kind: MotionKind,
1789 #[serde(default, skip_serializing_if = "Option::is_none")]
1791 pub duration: Option<f64>,
1792 #[serde(default, skip_serializing_if = "Option::is_none")]
1794 pub easing: Option<EasingChoice>,
1795 #[serde(default, skip_serializing_if = "Option::is_none")]
1797 pub direction: Option<Direction>,
1798 #[serde(default, skip_serializing_if = "Option::is_none")]
1800 pub distance: Option<f32>,
1801 #[serde(default, skip_serializing_if = "Option::is_none")]
1803 pub size: Option<f32>,
1804 #[serde(default, skip_serializing_if = "Option::is_none")]
1806 pub fade: Option<bool>,
1807}
1808
1809#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
1811#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1812#[serde(rename_all = "snake_case")]
1813pub enum MotionKind {
1814 Fade,
1816 Rise,
1818 Slide,
1820 Scale,
1822}
1823
1824#[derive(Clone, Copy, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
1826#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1827#[serde(rename_all = "snake_case")]
1828pub enum Direction {
1829 #[default]
1831 Up,
1832 Down,
1834 Left,
1836 Right,
1838}
1839
1840#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
1842#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1843#[serde(deny_unknown_fields)]
1844pub struct Reveal {
1845 pub by: RevealUnit,
1847 #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
1849 pub kind: Option<RevealKind>,
1850 #[serde(default, skip_serializing_if = "Option::is_none")]
1852 pub stagger: Option<f64>,
1853 #[serde(default, skip_serializing_if = "Option::is_none")]
1855 pub duration: Option<f64>,
1856 #[serde(default, skip_serializing_if = "Option::is_none")]
1858 pub distance: Option<f32>,
1859}
1860
1861#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
1863#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1864#[serde(rename_all = "snake_case")]
1865pub enum RevealUnit {
1866 Word,
1868 Line,
1870}
1871
1872#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
1874#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1875#[serde(rename_all = "snake_case")]
1876pub enum RevealKind {
1877 Fade,
1879 Rise,
1881}
1882
1883#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
1885#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1886#[serde(deny_unknown_fields)]
1887pub struct Counter {
1888 #[serde(default, skip_serializing_if = "Option::is_none")]
1890 pub id: Option<String>,
1891 pub start: f64,
1893 pub end: f64,
1895 #[serde(default, skip_serializing_if = "Option::is_none")]
1898 pub count_duration: Option<f64>,
1899 #[serde(default, skip_serializing_if = "Option::is_none")]
1901 pub easing: Option<EasingChoice>,
1902 #[serde(default, skip_serializing_if = "Option::is_none")]
1904 pub format: Option<NumberFormat>,
1905 #[serde(default, skip_serializing_if = "Option::is_none")]
1907 pub style: Option<TextRole>,
1908 #[serde(default, skip_serializing_if = "Option::is_none")]
1910 pub font_size: Option<Size>,
1911 #[serde(default, skip_serializing_if = "Option::is_none")]
1913 pub font_family: Option<String>,
1914 #[serde(default, skip_serializing_if = "Option::is_none")]
1916 pub color: Option<SolidColor>,
1917 #[serde(default, skip_serializing_if = "Vec::is_empty")]
1919 pub strokes: Vec<TextStroke>,
1920 #[serde(default, skip_serializing_if = "Vec::is_empty")]
1922 pub shadows: Vec<TextShadow>,
1923 #[serde(default, skip_serializing_if = "Option::is_none")]
1925 pub opacity: Option<f32>,
1926 #[serde(default, skip_serializing_if = "Option::is_none")]
1928 pub at: Option<f64>,
1929 #[serde(default, skip_serializing_if = "Option::is_none")]
1931 pub duration: Option<f64>,
1932 #[serde(default, skip_serializing_if = "Option::is_none")]
1934 pub inset: Option<Inset>,
1935 #[serde(default, skip_serializing_if = "Option::is_none")]
1937 pub align: Option<Align>,
1938 #[serde(default, skip_serializing_if = "Option::is_none")]
1940 pub enter: Option<Motion>,
1941 #[serde(default, skip_serializing_if = "Option::is_none")]
1943 pub exit: Option<Motion>,
1944}
1945
1946#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
1948#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1949#[serde(deny_unknown_fields)]
1950pub struct NumberFormat {
1951 #[serde(default, skip_serializing_if = "Option::is_none")]
1953 pub decimals: Option<u32>,
1954 #[serde(default, skip_serializing_if = "Option::is_none")]
1956 pub thousands: Option<String>,
1957 #[serde(default, skip_serializing_if = "Option::is_none")]
1959 pub point: Option<String>,
1960 #[serde(default, skip_serializing_if = "Option::is_none")]
1962 pub prefix: Option<String>,
1963 #[serde(default, skip_serializing_if = "Option::is_none")]
1965 pub suffix: Option<String>,
1966}