Something went wrong. Try again.
atproto Thingiverse but good
Something went wrong. Try again.
26 kB · 719 lines
Rust
at main
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719// @generated by jacquard-lexicon. DO NOT EDIT.//// Lexicon: space.polymodel.library.model//// 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::Cover;use crate::space_polymodel::library::Instructions;use crate::space_polymodel::library::IntendedToWorkWith;use crate::space_polymodel::library::Name;use crate::space_polymodel::library::Previews;use crate::space_polymodel::library::Tags;/// A model: an ordered set of parts; a variant of a thing.
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]#[serde( rename_all = "camelCase", rename = "space.polymodel.library.model", tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]pub struct Model<S: BosStr = DefaultStr> { #[serde(skip_serializing_if = "Option::is_none")] pub cover: Option<Cover<S>>, pub created_at: Datetime, #[serde(skip_serializing_if = "Option::is_none")] pub derived_from: Option<StrongRef<S>>, #[serde(skip_serializing_if = "Option::is_none")] pub instructions: Option<Instructions<S>>, #[serde(skip_serializing_if = "Option::is_none")] pub intended_to_work_with: Option<IntendedToWorkWith<S>>, #[serde(skip_serializing_if = "Option::is_none")] pub license: Option<S>, pub name: Name<S>, pub parts: Vec<StrongRef<S>>, #[serde(skip_serializing_if = "Option::is_none")] pub previews: Option<Previews<S>>, #[serde(skip_serializing_if = "Option::is_none")] pub summary: Option<S>, #[serde(skip_serializing_if = "Option::is_none")] pub tags: Option<Tags<S>>, #[serde(flatten, default, skip_serializing_if = "Option::is_none")] pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,}
/// 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 ModelGetRecordOutput<S: BosStr = DefaultStr> { #[serde(skip_serializing_if = "Option::is_none")] pub cid: Option<Cid<S>>, pub uri: AtUri<S>, pub value: Model<S>,}
impl<S: BosStr> Model<S> { pub fn uri(uri: S) -> Result<RecordUri<S, ModelRecord>, UriError> { RecordUri::try_from_uri(AtUri::new(uri)?) }}
/// Marker type for deserializing records from this collection.
#[derive(Debug, Serialize, Deserialize)]pub struct ModelRecord;impl XrpcResp for ModelRecord { const NSID: &'static str = "space.polymodel.library.model"; const ENCODING: &'static str = "application/json"; type Output<S: BosStr> = ModelGetRecordOutput<S>; type Err = RecordError;}
impl<S: BosStr> From<ModelGetRecordOutput<S>> for Model<S> { fn from(output: ModelGetRecordOutput<S>) -> Self { output.value }}
impl<S: BosStr> Collection for Model<S> { const NSID: &'static str = "space.polymodel.library.model"; type Record = ModelRecord;}
impl Collection for ModelRecord { const NSID: &'static str = "space.polymodel.library.model"; type Record = ModelRecord;}
impl<S: BosStr> LexiconSchema for Model<S> { fn nsid() -> &'static str { "space.polymodel.library.model" } fn def_name() -> &'static str { "main" } fn lexicon_doc() -> LexiconDoc<'static> { lexicon_doc_space_polymodel_library_model() } fn validate(&self) -> Result<(), ConstraintError> { if let Some(ref value) = self.cover { #[allow(unused_comparisons)] if value.len() > 8usize { return Err(ConstraintError::MaxLength { path: ValidationPath::from_field("cover"), max: 8usize, actual: value.len(), }); } } if let Some(ref value) = self.instructions { #[allow(unused_comparisons)] if value.len() > 100usize { return Err(ConstraintError::MaxLength { path: ValidationPath::from_field("instructions"), max: 100usize, actual: value.len(), }); } } 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 <str>::len(value.as_ref()) > 1024usize { return Err(ConstraintError::MaxLength { path: ValidationPath::from_field("name"), max: 1024usize, actual: <str>::len(value.as_ref()), }); } } { let value = &self.name; { let count = UnicodeSegmentation::graphemes(value.as_ref(), true).count(); if count > 256usize { return Err(ConstraintError::MaxGraphemes { path: ValidationPath::from_field("name"), max: 256usize, actual: count, }); } } } { let value = &self.parts; #[allow(unused_comparisons)] if value.len() > 1024usize { return Err(ConstraintError::MaxLength { path: ValidationPath::from_field("parts"), max: 1024usize, actual: value.len(), }); } } 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.summary { #[allow(unused_comparisons)] if <str>::len(value.as_ref()) > 8000usize { return Err(ConstraintError::MaxLength { path: ValidationPath::from_field("summary"), max: 8000usize, actual: <str>::len(value.as_ref()), }); } } if let Some(ref value) = self.summary { { let count = UnicodeSegmentation::graphemes(value.as_ref(), true).count(); if count > 4000usize { return Err(ConstraintError::MaxGraphemes { path: ValidationPath::from_field("summary"), max: 4000usize, actual: count, }); } } } if let Some(ref value) = self.tags { #[allow(unused_comparisons)] if value.len() > 16usize { return Err(ConstraintError::MaxLength { path: ValidationPath::from_field("tags"), max: 16usize, actual: value.len(), }); } } if let Some(values) = &self.tags { for value in values { #[allow(unused_comparisons)] if <str>::len(value.as_ref()) > 1024usize { return Err(ConstraintError::MaxLength { path: ValidationPath::from_field("tags"), max: 1024usize, actual: <str>::len(value.as_ref()), }); } } } if let Some(values) = &self.tags { for value in values { { let count = UnicodeSegmentation::graphemes(value.as_ref(), true) .count(); if count > 256usize { return Err(ConstraintError::MaxGraphemes { path: ValidationPath::from_field("tags"), max: 256usize, actual: count, }); } } } } Ok(()) }}
pub mod model_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 Name; type Parts; } /// Empty state - all required fields are unset pub struct Empty(()); impl sealed::Sealed for Empty {} impl State for Empty { type CreatedAt = Unset; type Name = Unset; type Parts = Unset; } ///State transition - sets the `created_at` field to Set pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetCreatedAt<St> {} impl<St: State> State for SetCreatedAt<St> { type CreatedAt = Set<members::created_at>; type Name = St::Name; type Parts = St::Parts; } ///State transition - sets the `name` field to Set pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetName<St> {} impl<St: State> State for SetName<St> { type CreatedAt = St::CreatedAt; type Name = Set<members::name>; type Parts = St::Parts; } ///State transition - sets the `parts` field to Set pub struct SetParts<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetParts<St> {} impl<St: State> State for SetParts<St> { type CreatedAt = St::CreatedAt; type Name = St::Name; type Parts = Set<members::parts>; } /// 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 `name` field pub struct name(()); ///Marker type for the `parts` field pub struct parts(()); }}
/// Builder for constructing an instance of this type.pub struct ModelBuilder<St: model_state::State, S: BosStr = DefaultStr> { _state: PhantomData<fn() -> St>, _fields: ( Option<Cover<S>>, Option<Datetime>, Option<StrongRef<S>>, Option<Instructions<S>>, Option<IntendedToWorkWith<S>>, Option<S>, Option<Name<S>>, Option<Vec<StrongRef<S>>>, Option<Previews<S>>, Option<S>, Option<Tags<S>>, ), _type: PhantomData<fn() -> S>,}
impl Model<DefaultStr> { /// Create a new builder for this type, using the default string type (DefaultStr = SmolStr) if needed pub fn new() -> ModelBuilder<model_state::Empty, DefaultStr> { ModelBuilder::new() }}
impl<S: BosStr> Model<S> { /// Create a new builder for this type pub fn builder() -> ModelBuilder<model_state::Empty, S> { ModelBuilder::builder() }}
impl ModelBuilder<model_state::Empty, DefaultStr> { /// Create a new builder with all fields unset, using the default string type, if needed pub fn new() -> Self { ModelBuilder { _state: PhantomData, _fields: (None, None, None, None, None, None, None, None, None, None, None), _type: PhantomData, } }}
impl<S: BosStr> ModelBuilder<model_state::Empty, S> { /// Create a new builder with all fields unset pub fn builder() -> Self { ModelBuilder { _state: PhantomData, _fields: (None, None, None, None, None, None, None, None, None, None, None), _type: PhantomData, } }}
impl<St: model_state::State, S: BosStr> ModelBuilder<St, S> { /// Set the `cover` field (optional) pub fn cover(mut self, value: impl Into<Option<Cover<S>>>) -> Self { self._fields.0 = value.into(); self } /// Set the `cover` field to an Option value (optional) pub fn maybe_cover(mut self, value: Option<Cover<S>>) -> Self { self._fields.0 = value; self }}
impl<St, S: BosStr> ModelBuilder<St, S>where St: model_state::State, St::CreatedAt: model_state::IsUnset,{ /// Set the `createdAt` field (required) pub fn created_at( mut self, value: impl Into<Datetime>, ) -> ModelBuilder<model_state::SetCreatedAt<St>, S> { self._fields.1 = Option::Some(value.into()); ModelBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St: model_state::State, S: BosStr> ModelBuilder<St, S> { /// Set the `derivedFrom` field (optional) pub fn derived_from(mut self, value: impl Into<Option<StrongRef<S>>>) -> Self { self._fields.2 = value.into(); self } /// Set the `derivedFrom` field to an Option value (optional) pub fn maybe_derived_from(mut self, value: Option<StrongRef<S>>) -> Self { self._fields.2 = value; self }}
impl<St: model_state::State, S: BosStr> ModelBuilder<St, S> { /// Set the `instructions` field (optional) pub fn instructions(mut self, value: impl Into<Option<Instructions<S>>>) -> Self { self._fields.3 = value.into(); self } /// Set the `instructions` field to an Option value (optional) pub fn maybe_instructions(mut self, value: Option<Instructions<S>>) -> Self { self._fields.3 = value; self }}
impl<St: model_state::State, S: BosStr> ModelBuilder<St, S> { /// Set the `intendedToWorkWith` field (optional) pub fn intended_to_work_with( mut self, value: impl Into<Option<IntendedToWorkWith<S>>>, ) -> Self { self._fields.4 = value.into(); self } /// Set the `intendedToWorkWith` field to an Option value (optional) pub fn maybe_intended_to_work_with( mut self, value: Option<IntendedToWorkWith<S>>, ) -> Self { self._fields.4 = value; self }}
impl<St: model_state::State, S: BosStr> ModelBuilder<St, S> { /// Set the `license` field (optional) pub fn license(mut self, value: impl Into<Option<S>>) -> Self { self._fields.5 = value.into(); self } /// Set the `license` field to an Option value (optional) pub fn maybe_license(mut self, value: Option<S>) -> Self { self._fields.5 = value; self }}
impl<St, S: BosStr> ModelBuilder<St, S>where St: model_state::State, St::Name: model_state::IsUnset,{ /// Set the `name` field (required) pub fn name( mut self, value: impl Into<Name<S>>, ) -> ModelBuilder<model_state::SetName<St>, S> { self._fields.6 = Option::Some(value.into()); ModelBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> ModelBuilder<St, S>where St: model_state::State, St::Parts: model_state::IsUnset,{ /// Set the `parts` field (required) pub fn parts( mut self, value: impl Into<Vec<StrongRef<S>>>, ) -> ModelBuilder<model_state::SetParts<St>, S> { self._fields.7 = Option::Some(value.into()); ModelBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St: model_state::State, S: BosStr> ModelBuilder<St, S> { /// Set the `previews` field (optional) pub fn previews(mut self, value: impl Into<Option<Previews<S>>>) -> Self { self._fields.8 = value.into(); self } /// Set the `previews` field to an Option value (optional) pub fn maybe_previews(mut self, value: Option<Previews<S>>) -> Self { self._fields.8 = value; self }}
impl<St: model_state::State, S: BosStr> ModelBuilder<St, S> { /// Set the `summary` field (optional) pub fn summary(mut self, value: impl Into<Option<S>>) -> Self { self._fields.9 = value.into(); self } /// Set the `summary` field to an Option value (optional) pub fn maybe_summary(mut self, value: Option<S>) -> Self { self._fields.9 = value; self }}
impl<St: model_state::State, S: BosStr> ModelBuilder<St, S> { /// Set the `tags` field (optional) pub fn tags(mut self, value: impl Into<Option<Tags<S>>>) -> Self { self._fields.10 = value.into(); self } /// Set the `tags` field to an Option value (optional) pub fn maybe_tags(mut self, value: Option<Tags<S>>) -> Self { self._fields.10 = value; self }}
impl<St, S: BosStr> ModelBuilder<St, S>where St: model_state::State, St::CreatedAt: model_state::IsSet, St::Name: model_state::IsSet, St::Parts: model_state::IsSet,{ /// Build the final struct. pub fn build(self) -> Model<S> { Model { cover: self._fields.0, created_at: self._fields.1.unwrap(), derived_from: self._fields.2, instructions: self._fields.3, intended_to_work_with: self._fields.4, license: self._fields.5, name: self._fields.6.unwrap(), parts: self._fields.7.unwrap(), previews: self._fields.8, summary: self._fields.9, tags: self._fields.10, extra_data: Default::default(), } } /// Build the final struct with custom extra_data. pub fn build_with_data(self, extra_data: BTreeMap<SmolStr, Data<S>>) -> Model<S> { Model { cover: self._fields.0, created_at: self._fields.1.unwrap(), derived_from: self._fields.2, instructions: self._fields.3, intended_to_work_with: self._fields.4, license: self._fields.5, name: self._fields.6.unwrap(), parts: self._fields.7.unwrap(), previews: self._fields.8, summary: self._fields.9, tags: self._fields.10, extra_data: Some(extra_data), } }}
fn lexicon_doc_space_polymodel_library_model() -> 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.model"), defs: { let mut map = BTreeMap::new(); map.insert( SmolStr::new_static("main"), LexUserType::Record(LexRecord { description: Some( CowStr::new_static( "A model: an ordered set of parts; a variant of a thing.", ), ), key: Some(CowStr::new_static("tid")), record: LexRecordRecord::Object(LexObject { required: Some( vec![ SmolStr::new_static("name"), SmolStr::new_static("parts"), SmolStr::new_static("createdAt") ], ), properties: { #[allow(unused_mut)] let mut map = BTreeMap::new(); map.insert( SmolStr::new_static("cover"), LexObjectProperty::Ref(LexRef { r#ref: CowStr::new_static( "space.polymodel.library.defs#cover", ), ..Default::default() }), ); 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("instructions"), LexObjectProperty::Ref(LexRef { r#ref: CowStr::new_static( "space.polymodel.library.defs#instructions", ), ..Default::default() }), ); map.insert( SmolStr::new_static("intendedToWorkWith"), LexObjectProperty::Ref(LexRef { r#ref: CowStr::new_static( "space.polymodel.library.defs#intendedToWorkWith", ), ..Default::default() }), ); map.insert( SmolStr::new_static("license"), LexObjectProperty::String(LexString { ..Default::default() }), ); map.insert( SmolStr::new_static("name"), LexObjectProperty::Ref(LexRef { r#ref: CowStr::new_static( "space.polymodel.library.defs#name", ), ..Default::default() }), ); map.insert( SmolStr::new_static("parts"), LexObjectProperty::Array(LexArray { items: LexArrayItem::Ref(LexRef { r#ref: CowStr::new_static("com.atproto.repo.strongRef"), ..Default::default() }), max_length: Some(1024usize), ..Default::default() }), ); map.insert( SmolStr::new_static("previews"), LexObjectProperty::Ref(LexRef { r#ref: CowStr::new_static( "space.polymodel.library.defs#previews", ), ..Default::default() }), ); map.insert( SmolStr::new_static("summary"), LexObjectProperty::String(LexString { max_length: Some(8000usize), max_graphemes: Some(4000usize), ..Default::default() }), ); map.insert( SmolStr::new_static("tags"), LexObjectProperty::Ref(LexRef { r#ref: CowStr::new_static( "space.polymodel.library.defs#tags", ), ..Default::default() }), ); map }, ..Default::default() }), ..Default::default() }), ); map }, ..Default::default() }}