// @generated by jacquard-lexicon. DO NOT EDIT. // // Lexicon: space.polymodel.library.part // // 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, BosStr, DefaultStr, FromStaticStr}; #[allow(unused_imports)] use jacquard_common::deps::codegen::unicode_segmentation::UnicodeSegmentation; use jacquard_common::deps::smol_str::SmolStr; use jacquard_common::types::collection::{Collection, RecordError}; use jacquard_common::types::string::{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::com_atproto::repo::strong_ref::StrongRef; use crate::space_polymodel::library::Bbox; use crate::space_polymodel::library::File; use crate::space_polymodel::library::Image; /// A part: a single printable geometry file (STL/3MF/OBJ; multi-body discouraged). #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)] #[serde( rename_all = "camelCase", rename = "space.polymodel.library.part", tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr") )] pub struct Part { pub created_at: Datetime, #[serde(skip_serializing_if = "Option::is_none")] pub derived_from: Option>, #[serde(skip_serializing_if = "Option::is_none")] pub dimensions: Option>, pub file: File, #[serde(skip_serializing_if = "Option::is_none")] pub format: Option, #[serde(skip_serializing_if = "Option::is_none")] pub intended_to_work_with: Option>>, pub name: S, #[serde(skip_serializing_if = "Option::is_none")] pub notes: Option, #[serde(skip_serializing_if = "Option::is_none")] pub previews: Option>>, #[serde(skip_serializing_if = "Option::is_none")] pub print_settings: Option>, /// Defaults to `"mm"`. #[serde(skip_serializing_if = "Option::is_none")] #[serde(default = "_default_part_units")] pub units: Option, #[serde(flatten, default, skip_serializing_if = "Option::is_none")] pub extra_data: 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 PartGetRecordOutput { #[serde(skip_serializing_if = "Option::is_none")] pub cid: Option>, pub uri: AtUri, pub value: Part, } impl Part { pub fn uri(uri: S) -> Result, UriError> { RecordUri::try_from_uri(AtUri::new(uri)?) } } /// Marker type for deserializing records from this collection. #[derive(Debug, Serialize, Deserialize)] pub struct PartRecord; impl XrpcResp for PartRecord { const NSID: &'static str = "space.polymodel.library.part"; const ENCODING: &'static str = "application/json"; type Output = PartGetRecordOutput; type Err = RecordError; } impl From> for Part { fn from(output: PartGetRecordOutput) -> Self { output.value } } impl Collection for Part { const NSID: &'static str = "space.polymodel.library.part"; type Record = PartRecord; } impl Collection for PartRecord { const NSID: &'static str = "space.polymodel.library.part"; type Record = PartRecord; } impl LexiconSchema for Part { fn nsid() -> &'static str { "space.polymodel.library.part" } fn def_name() -> &'static str { "main" } fn lexicon_doc() -> LexiconDoc<'static> { lexicon_doc_space_polymodel_library_part() } fn validate(&self) -> Result<(), ConstraintError> { if let Some(ref value) = self.intended_to_work_with { #[allow(unused_comparisons)] if value.len() > 32usize { return Err(ConstraintError::MaxLength { path: ValidationPath::from_field("intended_to_work_with"), max: 32usize, actual: value.len(), }); } } { let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 256usize { return Err(ConstraintError::MaxLength { path: ValidationPath::from_field("name"), max: 256usize, actual: ::len(value.as_ref()), }); } } { let value = &self.name; { let count = UnicodeSegmentation::graphemes(value.as_ref(), true).count(); if count > 64usize { return Err(ConstraintError::MaxGraphemes { path: ValidationPath::from_field("name"), max: 64usize, actual: count, }); } } } if let Some(ref value) = self.notes { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 2000usize { return Err(ConstraintError::MaxLength { path: ValidationPath::from_field("notes"), max: 2000usize, actual: ::len(value.as_ref()), }); } } if let Some(ref value) = self.notes { { let count = UnicodeSegmentation::graphemes(value.as_ref(), true).count(); if count > 300usize { return Err(ConstraintError::MaxGraphemes { path: ValidationPath::from_field("notes"), max: 300usize, actual: count, }); } } } if let Some(ref value) = self.previews { #[allow(unused_comparisons)] if value.len() > 12usize { return Err(ConstraintError::MaxLength { path: ValidationPath::from_field("previews"), max: 12usize, actual: value.len(), }); } } if let Some(ref value) = self.print_settings { #[allow(unused_comparisons)] if value.len() > 50usize { return Err(ConstraintError::MaxLength { path: ValidationPath::from_field("print_settings"), max: 50usize, actual: value.len(), }); } } Ok(()) } } fn _default_part_units() -> ::core::option::Option { Some(S::from_static("mm")) } pub mod part_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 CreatedAt; type File; type Name; } /// Empty state - all required fields are unset pub struct Empty(()); impl sealed::Sealed for Empty {} impl State for Empty { type CreatedAt = Unset; type File = Unset; type Name = Unset; } ///State transition - sets the `created_at` field to Set pub struct SetCreatedAt(PhantomData St>); impl sealed::Sealed for SetCreatedAt {} impl State for SetCreatedAt { type CreatedAt = Set; type File = St::File; type Name = St::Name; } ///State transition - sets the `file` field to Set pub struct SetFile(PhantomData St>); impl sealed::Sealed for SetFile {} impl State for SetFile { type CreatedAt = St::CreatedAt; type File = Set; type Name = St::Name; } ///State transition - sets the `name` field to Set pub struct SetName(PhantomData St>); impl sealed::Sealed for SetName {} impl State for SetName { type CreatedAt = St::CreatedAt; type File = St::File; type Name = Set; } /// Marker types for field names #[allow(non_camel_case_types)] pub mod members { ///Marker type for the `created_at` field pub struct created_at(()); ///Marker type for the `file` field pub struct file(()); ///Marker type for the `name` field pub struct name(()); } } /// Builder for constructing an instance of this type. pub struct PartBuilder { _state: PhantomData St>, _fields: ( Option, Option>, Option>, Option>, Option, Option>>, Option, Option, Option>>, Option>, Option, ), _type: PhantomData S>, } impl Part { /// Create a new builder for this type, using the default string type (DefaultStr = SmolStr) if needed pub fn new() -> PartBuilder { PartBuilder::new() } } impl Part { /// Create a new builder for this type pub fn builder() -> PartBuilder { PartBuilder::builder() } } impl PartBuilder { /// Create a new builder with all fields unset, using the default string type, if needed pub fn new() -> Self { PartBuilder { _state: PhantomData, _fields: (None, None, None, None, None, None, None, None, None, None, None), _type: PhantomData, } } } impl PartBuilder { /// Create a new builder with all fields unset pub fn builder() -> Self { PartBuilder { _state: PhantomData, _fields: (None, None, None, None, None, None, None, None, None, None, None), _type: PhantomData, } } } impl PartBuilder where St: part_state::State, St::CreatedAt: part_state::IsUnset, { /// Set the `createdAt` field (required) pub fn created_at( mut self, value: impl Into, ) -> PartBuilder, S> { self._fields.0 = Option::Some(value.into()); PartBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } } } impl PartBuilder { /// Set the `derivedFrom` field (optional) pub fn derived_from(mut self, value: impl Into>>) -> Self { self._fields.1 = value.into(); self } /// Set the `derivedFrom` field to an Option value (optional) pub fn maybe_derived_from(mut self, value: Option>) -> Self { self._fields.1 = value; self } } impl PartBuilder { /// Set the `dimensions` field (optional) pub fn dimensions(mut self, value: impl Into>>) -> Self { self._fields.2 = value.into(); self } /// Set the `dimensions` field to an Option value (optional) pub fn maybe_dimensions(mut self, value: Option>) -> Self { self._fields.2 = value; self } } impl PartBuilder where St: part_state::State, St::File: part_state::IsUnset, { /// Set the `file` field (required) pub fn file( mut self, value: impl Into>, ) -> PartBuilder, S> { self._fields.3 = Option::Some(value.into()); PartBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } } } impl PartBuilder { /// Set the `format` field (optional) pub fn format(mut self, value: impl Into>) -> Self { self._fields.4 = value.into(); self } /// Set the `format` field to an Option value (optional) pub fn maybe_format(mut self, value: Option) -> Self { self._fields.4 = value; self } } impl PartBuilder { /// Set the `intendedToWorkWith` field (optional) pub fn intended_to_work_with( mut self, value: impl Into>>>, ) -> Self { self._fields.5 = value.into(); self } /// Set the `intendedToWorkWith` field to an Option value (optional) pub fn maybe_intended_to_work_with( mut self, value: Option>>, ) -> Self { self._fields.5 = value; self } } impl PartBuilder where St: part_state::State, St::Name: part_state::IsUnset, { /// Set the `name` field (required) pub fn name( mut self, value: impl Into, ) -> PartBuilder, S> { self._fields.6 = Option::Some(value.into()); PartBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } } } impl PartBuilder { /// Set the `notes` field (optional) pub fn notes(mut self, value: impl Into>) -> Self { self._fields.7 = value.into(); self } /// Set the `notes` field to an Option value (optional) pub fn maybe_notes(mut self, value: Option) -> Self { self._fields.7 = value; self } } impl PartBuilder { /// Set the `previews` field (optional) pub fn previews(mut self, value: impl Into>>>) -> Self { self._fields.8 = value.into(); self } /// Set the `previews` field to an Option value (optional) pub fn maybe_previews(mut self, value: Option>>) -> Self { self._fields.8 = value; self } } impl PartBuilder { /// Set the `printSettings` field (optional) pub fn print_settings(mut self, value: impl Into>>) -> Self { self._fields.9 = value.into(); self } /// Set the `printSettings` field to an Option value (optional) pub fn maybe_print_settings(mut self, value: Option>) -> Self { self._fields.9 = value; self } } impl PartBuilder { /// Set the `units` field (optional) pub fn units(mut self, value: impl Into>) -> Self { self._fields.10 = value.into(); self } /// Set the `units` field to an Option value (optional) pub fn maybe_units(mut self, value: Option) -> Self { self._fields.10 = value; self } } impl PartBuilder where St: part_state::State, St::CreatedAt: part_state::IsSet, St::File: part_state::IsSet, St::Name: part_state::IsSet, { /// Build the final struct. pub fn build(self) -> Part { Part { created_at: self._fields.0.unwrap(), derived_from: self._fields.1, dimensions: self._fields.2, file: self._fields.3.unwrap(), format: self._fields.4, intended_to_work_with: self._fields.5, name: self._fields.6.unwrap(), notes: self._fields.7, previews: self._fields.8, print_settings: self._fields.9, units: self._fields.10.or_else(|| Some(S::from_static("mm"))), extra_data: Default::default(), } } /// Build the final struct with custom extra_data. pub fn build_with_data(self, extra_data: BTreeMap>) -> Part { Part { created_at: self._fields.0.unwrap(), derived_from: self._fields.1, dimensions: self._fields.2, file: self._fields.3.unwrap(), format: self._fields.4, intended_to_work_with: self._fields.5, name: self._fields.6.unwrap(), notes: self._fields.7, previews: self._fields.8, print_settings: self._fields.9, units: self._fields.10.or_else(|| Some(S::from_static("mm"))), extra_data: Some(extra_data), } } } fn lexicon_doc_space_polymodel_library_part() -> 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("space.polymodel.library.part"), defs: { let mut map = BTreeMap::new(); map.insert( SmolStr::new_static("main"), LexUserType::Record(LexRecord { description: Some( CowStr::new_static( "A part: a single printable geometry file (STL/3MF/OBJ; multi-body discouraged).", ), ), key: Some(CowStr::new_static("tid")), record: LexRecordRecord::Object(LexObject { required: Some( vec![ SmolStr::new_static("name"), SmolStr::new_static("file"), SmolStr::new_static("createdAt") ], ), properties: { #[allow(unused_mut)] let mut map = BTreeMap::new(); map.insert( SmolStr::new_static("createdAt"), LexObjectProperty::String(LexString { format: Some(LexStringFormat::Datetime), ..Default::default() }), ); map.insert( SmolStr::new_static("derivedFrom"), LexObjectProperty::Ref(LexRef { r#ref: CowStr::new_static("com.atproto.repo.strongRef"), ..Default::default() }), ); map.insert( SmolStr::new_static("dimensions"), LexObjectProperty::Ref(LexRef { r#ref: CowStr::new_static( "space.polymodel.library.defs#bbox", ), ..Default::default() }), ); map.insert( SmolStr::new_static("file"), LexObjectProperty::Ref(LexRef { r#ref: CowStr::new_static( "space.polymodel.library.defs#file", ), ..Default::default() }), ); map.insert( SmolStr::new_static("format"), LexObjectProperty::String(LexString { ..Default::default() }), ); map.insert( SmolStr::new_static("intendedToWorkWith"), LexObjectProperty::Array(LexArray { items: LexArrayItem::Ref(LexRef { r#ref: CowStr::new_static("com.atproto.repo.strongRef"), ..Default::default() }), max_length: Some(32usize), ..Default::default() }), ); map.insert( SmolStr::new_static("name"), LexObjectProperty::String(LexString { max_length: Some(256usize), max_graphemes: Some(64usize), ..Default::default() }), ); map.insert( SmolStr::new_static("notes"), LexObjectProperty::String(LexString { max_length: Some(2000usize), max_graphemes: Some(300usize), ..Default::default() }), ); map.insert( SmolStr::new_static("previews"), LexObjectProperty::Array(LexArray { items: LexArrayItem::Ref(LexRef { r#ref: CowStr::new_static( "space.polymodel.library.defs#image", ), ..Default::default() }), max_length: Some(12usize), ..Default::default() }), ); map.insert( SmolStr::new_static("printSettings"), LexObjectProperty::Array(LexArray { items: LexArrayItem::String(LexString { ..Default::default() }), max_length: Some(50usize), ..Default::default() }), ); map.insert( SmolStr::new_static("units"), LexObjectProperty::String(LexString { ..Default::default() }), ); map }, ..Default::default() }), ..Default::default() }), ); map }, ..Default::default() } }