// @generated by jacquard-lexicon. DO NOT EDIT. // // Lexicon: place.stream.segment // // This file was automatically generated from Lexicon schemas. // Any manual changes will be overwritten on the next regeneration. #[allow(unused_imports)] use alloc::collections::BTreeMap; #[allow(unused_imports)] use core::marker::PhantomData; use jacquard_common::CowStr; #[allow(unused_imports)] use jacquard_common::deps::codegen::unicode_segmentation::UnicodeSegmentation; use jacquard_common::types::collection::{Collection, RecordError}; use jacquard_common::types::string::{Did, AtUri, Cid, Datetime}; use jacquard_common::types::uri::{RecordUri, UriError}; use jacquard_common::types::value::Data; use jacquard_common::xrpc::XrpcResp; use jacquard_derive::{IntoStatic, lexicon}; use jacquard_lexicon::lexicon::LexiconDoc; use jacquard_lexicon::schema::LexiconSchema; #[allow(unused_imports)] use jacquard_lexicon::validation::{ConstraintError, ValidationPath}; use serde::{Serialize, Deserialize}; use crate::place_stream::metadata::content_rights::ContentRights; use crate::place_stream::metadata::content_warnings::ContentWarnings; use crate::place_stream::metadata::distribution_policy::DistributionPolicy; use crate::place_stream::segment; #[lexicon] #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)] #[serde(rename_all = "camelCase")] pub struct Audio<'a> { pub channels: i64, #[serde(borrow)] pub codec: CowStr<'a>, pub rate: i64, } #[lexicon] #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)] #[serde(rename_all = "camelCase")] pub struct Framerate<'a> { pub den: i64, pub num: i64, } /// Media file representing a segment of a livestream #[lexicon] #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)] #[serde(rename_all = "camelCase")] pub struct Segment<'a> { #[serde(skip_serializing_if = "Option::is_none")] #[serde(borrow)] pub audio: Option>>, #[serde(skip_serializing_if = "Option::is_none")] #[serde(borrow)] pub content_rights: Option>, #[serde(skip_serializing_if = "Option::is_none")] #[serde(borrow)] pub content_warnings: Option>, #[serde(borrow)] pub creator: Did<'a>, #[serde(skip_serializing_if = "Option::is_none")] #[serde(borrow)] pub distribution_policy: Option>, ///The duration of the segment in nanoseconds #[serde(skip_serializing_if = "Option::is_none")] pub duration: Option, ///Unique identifier for the segment #[serde(borrow)] pub id: CowStr<'a>, ///The DID of the signing key used for this segment #[serde(borrow)] pub signing_key: CowStr<'a>, ///The size of the segment in bytes #[serde(skip_serializing_if = "Option::is_none")] pub size: Option, ///When this segment started pub start_time: Datetime, #[serde(skip_serializing_if = "Option::is_none")] #[serde(borrow)] pub video: Option>>, } /// Typed wrapper for GetRecord response with this collection's record type. #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)] #[serde(rename_all = "camelCase")] pub struct SegmentGetRecordOutput<'a> { #[serde(skip_serializing_if = "Option::is_none")] #[serde(borrow)] pub cid: Option>, #[serde(borrow)] pub uri: AtUri<'a>, #[serde(borrow)] pub value: Segment<'a>, } #[lexicon] #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)] #[serde(rename_all = "camelCase")] pub struct SegmentView<'a> { #[serde(borrow)] pub cid: Cid<'a>, #[serde(borrow)] pub record: Data<'a>, } #[lexicon] #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)] #[serde(rename_all = "camelCase")] pub struct Video<'a> { #[serde(skip_serializing_if = "Option::is_none")] pub bframes: Option, #[serde(borrow)] pub codec: CowStr<'a>, #[serde(skip_serializing_if = "Option::is_none")] #[serde(borrow)] pub framerate: Option>, pub height: i64, pub width: i64, } impl<'a> Segment<'a> { pub fn uri( uri: impl Into>, ) -> Result, UriError> { RecordUri::try_from_uri(AtUri::new_cow(uri.into())?) } } impl<'a> LexiconSchema for Audio<'a> { fn nsid() -> &'static str { "place.stream.segment" } fn def_name() -> &'static str { "audio" } fn lexicon_doc() -> LexiconDoc<'static> { lexicon_doc_place_stream_segment() } fn validate(&self) -> Result<(), ConstraintError> { Ok(()) } } impl<'a> LexiconSchema for Framerate<'a> { fn nsid() -> &'static str { "place.stream.segment" } fn def_name() -> &'static str { "framerate" } fn lexicon_doc() -> LexiconDoc<'static> { lexicon_doc_place_stream_segment() } fn validate(&self) -> Result<(), ConstraintError> { Ok(()) } } /// Marker type for deserializing records from this collection. #[derive(Debug, Serialize, Deserialize)] pub struct SegmentRecord; impl XrpcResp for SegmentRecord { const NSID: &'static str = "place.stream.segment"; const ENCODING: &'static str = "application/json"; type Output<'de> = SegmentGetRecordOutput<'de>; type Err<'de> = RecordError<'de>; } impl From> for Segment<'_> { fn from(output: SegmentGetRecordOutput<'_>) -> Self { use jacquard_common::IntoStatic; output.value.into_static() } } impl Collection for Segment<'_> { const NSID: &'static str = "place.stream.segment"; type Record = SegmentRecord; } impl Collection for SegmentRecord { const NSID: &'static str = "place.stream.segment"; type Record = SegmentRecord; } impl<'a> LexiconSchema for Segment<'a> { fn nsid() -> &'static str { "place.stream.segment" } fn def_name() -> &'static str { "main" } fn lexicon_doc() -> LexiconDoc<'static> { lexicon_doc_place_stream_segment() } fn validate(&self) -> Result<(), ConstraintError> { Ok(()) } } impl<'a> LexiconSchema for SegmentView<'a> { fn nsid() -> &'static str { "place.stream.segment" } fn def_name() -> &'static str { "segmentView" } fn lexicon_doc() -> LexiconDoc<'static> { lexicon_doc_place_stream_segment() } fn validate(&self) -> Result<(), ConstraintError> { Ok(()) } } impl<'a> LexiconSchema for Video<'a> { fn nsid() -> &'static str { "place.stream.segment" } fn def_name() -> &'static str { "video" } fn lexicon_doc() -> LexiconDoc<'static> { lexicon_doc_place_stream_segment() } fn validate(&self) -> Result<(), ConstraintError> { Ok(()) } } pub mod audio_state { pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; #[allow(unused)] use ::core::marker::PhantomData; mod sealed { pub trait Sealed {} } /// State trait tracking which required fields have been set pub trait State: sealed::Sealed { type Rate; type Channels; type Codec; } /// Empty state - all required fields are unset pub struct Empty(()); impl sealed::Sealed for Empty {} impl State for Empty { type Rate = Unset; type Channels = Unset; type Codec = Unset; } ///State transition - sets the `rate` field to Set pub struct SetRate(PhantomData S>); impl sealed::Sealed for SetRate {} impl State for SetRate { type Rate = Set; type Channels = S::Channels; type Codec = S::Codec; } ///State transition - sets the `channels` field to Set pub struct SetChannels(PhantomData S>); impl sealed::Sealed for SetChannels {} impl State for SetChannels { type Rate = S::Rate; type Channels = Set; type Codec = S::Codec; } ///State transition - sets the `codec` field to Set pub struct SetCodec(PhantomData S>); impl sealed::Sealed for SetCodec {} impl State for SetCodec { type Rate = S::Rate; type Channels = S::Channels; type Codec = Set; } /// Marker types for field names #[allow(non_camel_case_types)] pub mod members { ///Marker type for the `rate` field pub struct rate(()); ///Marker type for the `channels` field pub struct channels(()); ///Marker type for the `codec` field pub struct codec(()); } } /// Builder for constructing an instance of this type pub struct AudioBuilder<'a, S: audio_state::State> { _state: PhantomData S>, _fields: (Option, Option>, Option), _lifetime: PhantomData<&'a ()>, } impl<'a> Audio<'a> { /// Create a new builder for this type pub fn new() -> AudioBuilder<'a, audio_state::Empty> { AudioBuilder::new() } } impl<'a> AudioBuilder<'a, audio_state::Empty> { /// Create a new builder with all fields unset pub fn new() -> Self { AudioBuilder { _state: PhantomData, _fields: (None, None, None), _lifetime: PhantomData, } } } impl<'a, S> AudioBuilder<'a, S> where S: audio_state::State, S::Channels: audio_state::IsUnset, { /// Set the `channels` field (required) pub fn channels( mut self, value: impl Into, ) -> AudioBuilder<'a, audio_state::SetChannels> { self._fields.0 = Option::Some(value.into()); AudioBuilder { _state: PhantomData, _fields: self._fields, _lifetime: PhantomData, } } } impl<'a, S> AudioBuilder<'a, S> where S: audio_state::State, S::Codec: audio_state::IsUnset, { /// Set the `codec` field (required) pub fn codec( mut self, value: impl Into>, ) -> AudioBuilder<'a, audio_state::SetCodec> { self._fields.1 = Option::Some(value.into()); AudioBuilder { _state: PhantomData, _fields: self._fields, _lifetime: PhantomData, } } } impl<'a, S> AudioBuilder<'a, S> where S: audio_state::State, S::Rate: audio_state::IsUnset, { /// Set the `rate` field (required) pub fn rate( mut self, value: impl Into, ) -> AudioBuilder<'a, audio_state::SetRate> { self._fields.2 = Option::Some(value.into()); AudioBuilder { _state: PhantomData, _fields: self._fields, _lifetime: PhantomData, } } } impl<'a, S> AudioBuilder<'a, S> where S: audio_state::State, S::Rate: audio_state::IsSet, S::Channels: audio_state::IsSet, S::Codec: audio_state::IsSet, { /// Build the final struct pub fn build(self) -> Audio<'a> { Audio { channels: self._fields.0.unwrap(), codec: self._fields.1.unwrap(), rate: self._fields.2.unwrap(), extra_data: Default::default(), } } /// Build the final struct with custom extra_data pub fn build_with_data( self, extra_data: BTreeMap>, ) -> Audio<'a> { Audio { channels: self._fields.0.unwrap(), codec: self._fields.1.unwrap(), rate: self._fields.2.unwrap(), extra_data: Some(extra_data), } } } fn lexicon_doc_place_stream_segment() -> LexiconDoc<'static> { #[allow(unused_imports)] use jacquard_common::{CowStr, deps::smol_str::SmolStr, types::blob::MimeType}; use jacquard_lexicon::lexicon::*; use alloc::collections::BTreeMap; LexiconDoc { lexicon: Lexicon::Lexicon1, id: CowStr::new_static("place.stream.segment"), defs: { let mut map = BTreeMap::new(); map.insert( SmolStr::new_static("audio"), LexUserType::Object(LexObject { required: Some( vec![ SmolStr::new_static("codec"), SmolStr::new_static("rate"), SmolStr::new_static("channels") ], ), properties: { #[allow(unused_mut)] let mut map = BTreeMap::new(); map.insert( SmolStr::new_static("channels"), LexObjectProperty::Integer(LexInteger { ..Default::default() }), ); map.insert( SmolStr::new_static("codec"), LexObjectProperty::String(LexString { ..Default::default() }), ); map.insert( SmolStr::new_static("rate"), LexObjectProperty::Integer(LexInteger { ..Default::default() }), ); map }, ..Default::default() }), ); map.insert( SmolStr::new_static("framerate"), LexUserType::Object(LexObject { required: Some( vec![SmolStr::new_static("num"), SmolStr::new_static("den")], ), properties: { #[allow(unused_mut)] let mut map = BTreeMap::new(); map.insert( SmolStr::new_static("den"), LexObjectProperty::Integer(LexInteger { ..Default::default() }), ); map.insert( SmolStr::new_static("num"), LexObjectProperty::Integer(LexInteger { ..Default::default() }), ); map }, ..Default::default() }), ); map.insert( SmolStr::new_static("main"), LexUserType::Record(LexRecord { description: Some( CowStr::new_static( "Media file representing a segment of a livestream", ), ), key: Some(CowStr::new_static("tid")), record: LexRecordRecord::Object(LexObject { required: Some( vec![ SmolStr::new_static("id"), SmolStr::new_static("signingKey"), SmolStr::new_static("startTime"), SmolStr::new_static("creator") ], ), properties: { #[allow(unused_mut)] let mut map = BTreeMap::new(); map.insert( SmolStr::new_static("audio"), LexObjectProperty::Array(LexArray { items: LexArrayItem::Ref(LexRef { r#ref: CowStr::new_static("#audio"), ..Default::default() }), ..Default::default() }), ); map.insert( SmolStr::new_static("contentRights"), LexObjectProperty::Ref(LexRef { r#ref: CowStr::new_static( "place.stream.metadata.contentRights", ), ..Default::default() }), ); map.insert( SmolStr::new_static("contentWarnings"), LexObjectProperty::Ref(LexRef { r#ref: CowStr::new_static( "place.stream.metadata.contentWarnings", ), ..Default::default() }), ); map.insert( SmolStr::new_static("creator"), LexObjectProperty::String(LexString { format: Some(LexStringFormat::Did), ..Default::default() }), ); map.insert( SmolStr::new_static("distributionPolicy"), LexObjectProperty::Ref(LexRef { r#ref: CowStr::new_static( "place.stream.metadata.distributionPolicy", ), ..Default::default() }), ); map.insert( SmolStr::new_static("duration"), LexObjectProperty::Integer(LexInteger { ..Default::default() }), ); map.insert( SmolStr::new_static("id"), LexObjectProperty::String(LexString { description: Some( CowStr::new_static("Unique identifier for the segment"), ), ..Default::default() }), ); map.insert( SmolStr::new_static("signingKey"), LexObjectProperty::String(LexString { description: Some( CowStr::new_static( "The DID of the signing key used for this segment", ), ), ..Default::default() }), ); map.insert( SmolStr::new_static("size"), LexObjectProperty::Integer(LexInteger { ..Default::default() }), ); map.insert( SmolStr::new_static("startTime"), LexObjectProperty::String(LexString { description: Some( CowStr::new_static("When this segment started"), ), format: Some(LexStringFormat::Datetime), ..Default::default() }), ); map.insert( SmolStr::new_static("video"), LexObjectProperty::Array(LexArray { items: LexArrayItem::Ref(LexRef { r#ref: CowStr::new_static("#video"), ..Default::default() }), ..Default::default() }), ); map }, ..Default::default() }), ..Default::default() }), ); map.insert( SmolStr::new_static("segmentView"), LexUserType::Object(LexObject { required: Some( vec![SmolStr::new_static("cid"), SmolStr::new_static("record")], ), properties: { #[allow(unused_mut)] let mut map = BTreeMap::new(); map.insert( SmolStr::new_static("cid"), LexObjectProperty::String(LexString { format: Some(LexStringFormat::Cid), ..Default::default() }), ); map.insert( SmolStr::new_static("record"), LexObjectProperty::Unknown(LexUnknown { ..Default::default() }), ); map }, ..Default::default() }), ); map.insert( SmolStr::new_static("video"), LexUserType::Object(LexObject { required: Some( vec![ SmolStr::new_static("codec"), SmolStr::new_static("width"), SmolStr::new_static("height") ], ), properties: { #[allow(unused_mut)] let mut map = BTreeMap::new(); map.insert( SmolStr::new_static("bframes"), LexObjectProperty::Boolean(LexBoolean { ..Default::default() }), ); map.insert( SmolStr::new_static("codec"), LexObjectProperty::String(LexString { ..Default::default() }), ); map.insert( SmolStr::new_static("framerate"), LexObjectProperty::Ref(LexRef { r#ref: CowStr::new_static("#framerate"), ..Default::default() }), ); map.insert( SmolStr::new_static("height"), LexObjectProperty::Integer(LexInteger { ..Default::default() }), ); map.insert( SmolStr::new_static("width"), LexObjectProperty::Integer(LexInteger { ..Default::default() }), ); map }, ..Default::default() }), ); map }, ..Default::default() } } pub mod framerate_state { pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; #[allow(unused)] use ::core::marker::PhantomData; mod sealed { pub trait Sealed {} } /// State trait tracking which required fields have been set pub trait State: sealed::Sealed { type Num; type Den; } /// Empty state - all required fields are unset pub struct Empty(()); impl sealed::Sealed for Empty {} impl State for Empty { type Num = Unset; type Den = Unset; } ///State transition - sets the `num` field to Set pub struct SetNum(PhantomData S>); impl sealed::Sealed for SetNum {} impl State for SetNum { type Num = Set; type Den = S::Den; } ///State transition - sets the `den` field to Set pub struct SetDen(PhantomData S>); impl sealed::Sealed for SetDen {} impl State for SetDen { type Num = S::Num; type Den = Set; } /// Marker types for field names #[allow(non_camel_case_types)] pub mod members { ///Marker type for the `num` field pub struct num(()); ///Marker type for the `den` field pub struct den(()); } } /// Builder for constructing an instance of this type pub struct FramerateBuilder<'a, S: framerate_state::State> { _state: PhantomData S>, _fields: (Option, Option), _lifetime: PhantomData<&'a ()>, } impl<'a> Framerate<'a> { /// Create a new builder for this type pub fn new() -> FramerateBuilder<'a, framerate_state::Empty> { FramerateBuilder::new() } } impl<'a> FramerateBuilder<'a, framerate_state::Empty> { /// Create a new builder with all fields unset pub fn new() -> Self { FramerateBuilder { _state: PhantomData, _fields: (None, None), _lifetime: PhantomData, } } } impl<'a, S> FramerateBuilder<'a, S> where S: framerate_state::State, S::Den: framerate_state::IsUnset, { /// Set the `den` field (required) pub fn den( mut self, value: impl Into, ) -> FramerateBuilder<'a, framerate_state::SetDen> { self._fields.0 = Option::Some(value.into()); FramerateBuilder { _state: PhantomData, _fields: self._fields, _lifetime: PhantomData, } } } impl<'a, S> FramerateBuilder<'a, S> where S: framerate_state::State, S::Num: framerate_state::IsUnset, { /// Set the `num` field (required) pub fn num( mut self, value: impl Into, ) -> FramerateBuilder<'a, framerate_state::SetNum> { self._fields.1 = Option::Some(value.into()); FramerateBuilder { _state: PhantomData, _fields: self._fields, _lifetime: PhantomData, } } } impl<'a, S> FramerateBuilder<'a, S> where S: framerate_state::State, S::Num: framerate_state::IsSet, S::Den: framerate_state::IsSet, { /// Build the final struct pub fn build(self) -> Framerate<'a> { Framerate { den: self._fields.0.unwrap(), num: self._fields.1.unwrap(), extra_data: Default::default(), } } /// Build the final struct with custom extra_data pub fn build_with_data( self, extra_data: BTreeMap>, ) -> Framerate<'a> { Framerate { den: self._fields.0.unwrap(), num: self._fields.1.unwrap(), extra_data: Some(extra_data), } } } pub mod segment_state { pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; #[allow(unused)] use ::core::marker::PhantomData; mod sealed { pub trait Sealed {} } /// State trait tracking which required fields have been set pub trait State: sealed::Sealed { type SigningKey; type StartTime; type Id; type Creator; } /// Empty state - all required fields are unset pub struct Empty(()); impl sealed::Sealed for Empty {} impl State for Empty { type SigningKey = Unset; type StartTime = Unset; type Id = Unset; type Creator = Unset; } ///State transition - sets the `signing_key` field to Set pub struct SetSigningKey(PhantomData S>); impl sealed::Sealed for SetSigningKey {} impl State for SetSigningKey { type SigningKey = Set; type StartTime = S::StartTime; type Id = S::Id; type Creator = S::Creator; } ///State transition - sets the `start_time` field to Set pub struct SetStartTime(PhantomData S>); impl sealed::Sealed for SetStartTime {} impl State for SetStartTime { type SigningKey = S::SigningKey; type StartTime = Set; type Id = S::Id; type Creator = S::Creator; } ///State transition - sets the `id` field to Set pub struct SetId(PhantomData S>); impl sealed::Sealed for SetId {} impl State for SetId { type SigningKey = S::SigningKey; type StartTime = S::StartTime; type Id = Set; type Creator = S::Creator; } ///State transition - sets the `creator` field to Set pub struct SetCreator(PhantomData S>); impl sealed::Sealed for SetCreator {} impl State for SetCreator { type SigningKey = S::SigningKey; type StartTime = S::StartTime; type Id = S::Id; type Creator = Set; } /// Marker types for field names #[allow(non_camel_case_types)] pub mod members { ///Marker type for the `signing_key` field pub struct signing_key(()); ///Marker type for the `start_time` field pub struct start_time(()); ///Marker type for the `id` field pub struct id(()); ///Marker type for the `creator` field pub struct creator(()); } } /// Builder for constructing an instance of this type pub struct SegmentBuilder<'a, S: segment_state::State> { _state: PhantomData S>, _fields: ( Option>>, Option>, Option>, Option>, Option>, Option, Option>, Option>, Option, Option, Option>>, ), _lifetime: PhantomData<&'a ()>, } impl<'a> Segment<'a> { /// Create a new builder for this type pub fn new() -> SegmentBuilder<'a, segment_state::Empty> { SegmentBuilder::new() } } impl<'a> SegmentBuilder<'a, segment_state::Empty> { /// Create a new builder with all fields unset pub fn new() -> Self { SegmentBuilder { _state: PhantomData, _fields: (None, None, None, None, None, None, None, None, None, None, None), _lifetime: PhantomData, } } } impl<'a, S: segment_state::State> SegmentBuilder<'a, S> { /// Set the `audio` field (optional) pub fn audio(mut self, value: impl Into>>>) -> Self { self._fields.0 = value.into(); self } /// Set the `audio` field to an Option value (optional) pub fn maybe_audio(mut self, value: Option>>) -> Self { self._fields.0 = value; self } } impl<'a, S: segment_state::State> SegmentBuilder<'a, S> { /// Set the `contentRights` field (optional) pub fn content_rights( mut self, value: impl Into>>, ) -> Self { self._fields.1 = value.into(); self } /// Set the `contentRights` field to an Option value (optional) pub fn maybe_content_rights(mut self, value: Option>) -> Self { self._fields.1 = value; self } } impl<'a, S: segment_state::State> SegmentBuilder<'a, S> { /// Set the `contentWarnings` field (optional) pub fn content_warnings( mut self, value: impl Into>>, ) -> Self { self._fields.2 = value.into(); self } /// Set the `contentWarnings` field to an Option value (optional) pub fn maybe_content_warnings(mut self, value: Option>) -> Self { self._fields.2 = value; self } } impl<'a, S> SegmentBuilder<'a, S> where S: segment_state::State, S::Creator: segment_state::IsUnset, { /// Set the `creator` field (required) pub fn creator( mut self, value: impl Into>, ) -> SegmentBuilder<'a, segment_state::SetCreator> { self._fields.3 = Option::Some(value.into()); SegmentBuilder { _state: PhantomData, _fields: self._fields, _lifetime: PhantomData, } } } impl<'a, S: segment_state::State> SegmentBuilder<'a, S> { /// Set the `distributionPolicy` field (optional) pub fn distribution_policy( mut self, value: impl Into>>, ) -> Self { self._fields.4 = value.into(); self } /// Set the `distributionPolicy` field to an Option value (optional) pub fn maybe_distribution_policy( mut self, value: Option>, ) -> Self { self._fields.4 = value; self } } impl<'a, S: segment_state::State> SegmentBuilder<'a, S> { /// Set the `duration` field (optional) pub fn duration(mut self, value: impl Into>) -> Self { self._fields.5 = value.into(); self } /// Set the `duration` field to an Option value (optional) pub fn maybe_duration(mut self, value: Option) -> Self { self._fields.5 = value; self } } impl<'a, S> SegmentBuilder<'a, S> where S: segment_state::State, S::Id: segment_state::IsUnset, { /// Set the `id` field (required) pub fn id( mut self, value: impl Into>, ) -> SegmentBuilder<'a, segment_state::SetId> { self._fields.6 = Option::Some(value.into()); SegmentBuilder { _state: PhantomData, _fields: self._fields, _lifetime: PhantomData, } } } impl<'a, S> SegmentBuilder<'a, S> where S: segment_state::State, S::SigningKey: segment_state::IsUnset, { /// Set the `signingKey` field (required) pub fn signing_key( mut self, value: impl Into>, ) -> SegmentBuilder<'a, segment_state::SetSigningKey> { self._fields.7 = Option::Some(value.into()); SegmentBuilder { _state: PhantomData, _fields: self._fields, _lifetime: PhantomData, } } } impl<'a, S: segment_state::State> SegmentBuilder<'a, S> { /// Set the `size` field (optional) pub fn size(mut self, value: impl Into>) -> Self { self._fields.8 = value.into(); self } /// Set the `size` field to an Option value (optional) pub fn maybe_size(mut self, value: Option) -> Self { self._fields.8 = value; self } } impl<'a, S> SegmentBuilder<'a, S> where S: segment_state::State, S::StartTime: segment_state::IsUnset, { /// Set the `startTime` field (required) pub fn start_time( mut self, value: impl Into, ) -> SegmentBuilder<'a, segment_state::SetStartTime> { self._fields.9 = Option::Some(value.into()); SegmentBuilder { _state: PhantomData, _fields: self._fields, _lifetime: PhantomData, } } } impl<'a, S: segment_state::State> SegmentBuilder<'a, S> { /// Set the `video` field (optional) pub fn video(mut self, value: impl Into>>>) -> Self { self._fields.10 = value.into(); self } /// Set the `video` field to an Option value (optional) pub fn maybe_video(mut self, value: Option>>) -> Self { self._fields.10 = value; self } } impl<'a, S> SegmentBuilder<'a, S> where S: segment_state::State, S::SigningKey: segment_state::IsSet, S::StartTime: segment_state::IsSet, S::Id: segment_state::IsSet, S::Creator: segment_state::IsSet, { /// Build the final struct pub fn build(self) -> Segment<'a> { Segment { audio: self._fields.0, content_rights: self._fields.1, content_warnings: self._fields.2, creator: self._fields.3.unwrap(), distribution_policy: self._fields.4, duration: self._fields.5, id: self._fields.6.unwrap(), signing_key: self._fields.7.unwrap(), size: self._fields.8, start_time: self._fields.9.unwrap(), video: self._fields.10, extra_data: Default::default(), } } /// Build the final struct with custom extra_data pub fn build_with_data( self, extra_data: BTreeMap>, ) -> Segment<'a> { Segment { audio: self._fields.0, content_rights: self._fields.1, content_warnings: self._fields.2, creator: self._fields.3.unwrap(), distribution_policy: self._fields.4, duration: self._fields.5, id: self._fields.6.unwrap(), signing_key: self._fields.7.unwrap(), size: self._fields.8, start_time: self._fields.9.unwrap(), video: self._fields.10, extra_data: Some(extra_data), } } } pub mod segment_view_state { pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; #[allow(unused)] use ::core::marker::PhantomData; mod sealed { pub trait Sealed {} } /// State trait tracking which required fields have been set pub trait State: sealed::Sealed { type Record; type Cid; } /// Empty state - all required fields are unset pub struct Empty(()); impl sealed::Sealed for Empty {} impl State for Empty { type Record = Unset; type Cid = Unset; } ///State transition - sets the `record` field to Set pub struct SetRecord(PhantomData S>); impl sealed::Sealed for SetRecord {} impl State for SetRecord { type Record = Set; type Cid = S::Cid; } ///State transition - sets the `cid` field to Set pub struct SetCid(PhantomData S>); impl sealed::Sealed for SetCid {} impl State for SetCid { type Record = S::Record; type Cid = Set; } /// Marker types for field names #[allow(non_camel_case_types)] pub mod members { ///Marker type for the `record` field pub struct record(()); ///Marker type for the `cid` field pub struct cid(()); } } /// Builder for constructing an instance of this type pub struct SegmentViewBuilder<'a, S: segment_view_state::State> { _state: PhantomData S>, _fields: (Option>, Option>), _lifetime: PhantomData<&'a ()>, } impl<'a> SegmentView<'a> { /// Create a new builder for this type pub fn new() -> SegmentViewBuilder<'a, segment_view_state::Empty> { SegmentViewBuilder::new() } } impl<'a> SegmentViewBuilder<'a, segment_view_state::Empty> { /// Create a new builder with all fields unset pub fn new() -> Self { SegmentViewBuilder { _state: PhantomData, _fields: (None, None), _lifetime: PhantomData, } } } impl<'a, S> SegmentViewBuilder<'a, S> where S: segment_view_state::State, S::Cid: segment_view_state::IsUnset, { /// Set the `cid` field (required) pub fn cid( mut self, value: impl Into>, ) -> SegmentViewBuilder<'a, segment_view_state::SetCid> { self._fields.0 = Option::Some(value.into()); SegmentViewBuilder { _state: PhantomData, _fields: self._fields, _lifetime: PhantomData, } } } impl<'a, S> SegmentViewBuilder<'a, S> where S: segment_view_state::State, S::Record: segment_view_state::IsUnset, { /// Set the `record` field (required) pub fn record( mut self, value: impl Into>, ) -> SegmentViewBuilder<'a, segment_view_state::SetRecord> { self._fields.1 = Option::Some(value.into()); SegmentViewBuilder { _state: PhantomData, _fields: self._fields, _lifetime: PhantomData, } } } impl<'a, S> SegmentViewBuilder<'a, S> where S: segment_view_state::State, S::Record: segment_view_state::IsSet, S::Cid: segment_view_state::IsSet, { /// Build the final struct pub fn build(self) -> SegmentView<'a> { SegmentView { cid: self._fields.0.unwrap(), record: self._fields.1.unwrap(), extra_data: Default::default(), } } /// Build the final struct with custom extra_data pub fn build_with_data( self, extra_data: BTreeMap>, ) -> SegmentView<'a> { SegmentView { cid: self._fields.0.unwrap(), record: self._fields.1.unwrap(), extra_data: Some(extra_data), } } } pub mod video_state { pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; #[allow(unused)] use ::core::marker::PhantomData; mod sealed { pub trait Sealed {} } /// State trait tracking which required fields have been set pub trait State: sealed::Sealed { type Width; type Codec; type Height; } /// Empty state - all required fields are unset pub struct Empty(()); impl sealed::Sealed for Empty {} impl State for Empty { type Width = Unset; type Codec = Unset; type Height = Unset; } ///State transition - sets the `width` field to Set pub struct SetWidth(PhantomData S>); impl sealed::Sealed for SetWidth {} impl State for SetWidth { type Width = Set; type Codec = S::Codec; type Height = S::Height; } ///State transition - sets the `codec` field to Set pub struct SetCodec(PhantomData S>); impl sealed::Sealed for SetCodec {} impl State for SetCodec { type Width = S::Width; type Codec = Set; type Height = S::Height; } ///State transition - sets the `height` field to Set pub struct SetHeight(PhantomData S>); impl sealed::Sealed for SetHeight {} impl State for SetHeight { type Width = S::Width; type Codec = S::Codec; type Height = Set; } /// Marker types for field names #[allow(non_camel_case_types)] pub mod members { ///Marker type for the `width` field pub struct width(()); ///Marker type for the `codec` field pub struct codec(()); ///Marker type for the `height` field pub struct height(()); } } /// Builder for constructing an instance of this type pub struct VideoBuilder<'a, S: video_state::State> { _state: PhantomData S>, _fields: ( Option, Option>, Option>, Option, Option, ), _lifetime: PhantomData<&'a ()>, } impl<'a> Video<'a> { /// Create a new builder for this type pub fn new() -> VideoBuilder<'a, video_state::Empty> { VideoBuilder::new() } } impl<'a> VideoBuilder<'a, video_state::Empty> { /// Create a new builder with all fields unset pub fn new() -> Self { VideoBuilder { _state: PhantomData, _fields: (None, None, None, None, None), _lifetime: PhantomData, } } } impl<'a, S: video_state::State> VideoBuilder<'a, S> { /// Set the `bframes` field (optional) pub fn bframes(mut self, value: impl Into>) -> Self { self._fields.0 = value.into(); self } /// Set the `bframes` field to an Option value (optional) pub fn maybe_bframes(mut self, value: Option) -> Self { self._fields.0 = value; self } } impl<'a, S> VideoBuilder<'a, S> where S: video_state::State, S::Codec: video_state::IsUnset, { /// Set the `codec` field (required) pub fn codec( mut self, value: impl Into>, ) -> VideoBuilder<'a, video_state::SetCodec> { self._fields.1 = Option::Some(value.into()); VideoBuilder { _state: PhantomData, _fields: self._fields, _lifetime: PhantomData, } } } impl<'a, S: video_state::State> VideoBuilder<'a, S> { /// Set the `framerate` field (optional) pub fn framerate( mut self, value: impl Into>>, ) -> Self { self._fields.2 = value.into(); self } /// Set the `framerate` field to an Option value (optional) pub fn maybe_framerate(mut self, value: Option>) -> Self { self._fields.2 = value; self } } impl<'a, S> VideoBuilder<'a, S> where S: video_state::State, S::Height: video_state::IsUnset, { /// Set the `height` field (required) pub fn height( mut self, value: impl Into, ) -> VideoBuilder<'a, video_state::SetHeight> { self._fields.3 = Option::Some(value.into()); VideoBuilder { _state: PhantomData, _fields: self._fields, _lifetime: PhantomData, } } } impl<'a, S> VideoBuilder<'a, S> where S: video_state::State, S::Width: video_state::IsUnset, { /// Set the `width` field (required) pub fn width( mut self, value: impl Into, ) -> VideoBuilder<'a, video_state::SetWidth> { self._fields.4 = Option::Some(value.into()); VideoBuilder { _state: PhantomData, _fields: self._fields, _lifetime: PhantomData, } } } impl<'a, S> VideoBuilder<'a, S> where S: video_state::State, S::Width: video_state::IsSet, S::Codec: video_state::IsSet, S::Height: video_state::IsSet, { /// Build the final struct pub fn build(self) -> Video<'a> { Video { bframes: self._fields.0, codec: self._fields.1.unwrap(), framerate: self._fields.2, height: self._fields.3.unwrap(), width: self._fields.4.unwrap(), extra_data: Default::default(), } } /// Build the final struct with custom extra_data pub fn build_with_data( self, extra_data: BTreeMap>, ) -> Video<'a> { Video { bframes: self._fields.0, codec: self._fields.1.unwrap(), framerate: self._fields.2, height: self._fields.3.unwrap(), width: self._fields.4.unwrap(), extra_data: Some(extra_data), } } }