// @generated by jacquard-lexicon. DO NOT EDIT. // // Lexicon: tools.ozone.set.defs // // This file was automatically generated from Lexicon schemas. // Any manual changes will be overwritten on the next regeneration. pub mod add_values; pub mod delete_set; pub mod delete_values; pub mod get_values; pub mod query_sets; pub mod upsert_set; #[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::string::Datetime; 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}; #[lexicon] #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)] #[serde(rename_all = "camelCase")] pub struct Set<'a> { #[serde(skip_serializing_if = "Option::is_none")] #[serde(borrow)] pub description: Option>, #[serde(borrow)] pub name: CowStr<'a>, } #[lexicon] #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)] #[serde(rename_all = "camelCase")] pub struct SetView<'a> { pub created_at: Datetime, #[serde(skip_serializing_if = "Option::is_none")] #[serde(borrow)] pub description: Option>, #[serde(borrow)] pub name: CowStr<'a>, pub set_size: i64, pub updated_at: Datetime, } impl<'a> LexiconSchema for Set<'a> { fn nsid() -> &'static str { "tools.ozone.set.defs" } fn def_name() -> &'static str { "set" } fn lexicon_doc() -> LexiconDoc<'static> { lexicon_doc_tools_ozone_set_defs() } fn validate(&self) -> Result<(), ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 10240usize { return Err(ConstraintError::MaxLength { path: ValidationPath::from_field("description"), max: 10240usize, actual: ::len(value.as_ref()), }); } } if let Some(ref value) = self.description { { let count = UnicodeSegmentation::graphemes(value.as_ref(), true).count(); if count > 1024usize { return Err(ConstraintError::MaxGraphemes { path: ValidationPath::from_field("description"), max: 1024usize, actual: count, }); } } } { let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 128usize { return Err(ConstraintError::MaxLength { path: ValidationPath::from_field("name"), max: 128usize, actual: ::len(value.as_ref()), }); } } { let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 3usize { return Err(ConstraintError::MinLength { path: ValidationPath::from_field("name"), min: 3usize, actual: ::len(value.as_ref()), }); } } Ok(()) } } impl<'a> LexiconSchema for SetView<'a> { fn nsid() -> &'static str { "tools.ozone.set.defs" } fn def_name() -> &'static str { "setView" } fn lexicon_doc() -> LexiconDoc<'static> { lexicon_doc_tools_ozone_set_defs() } fn validate(&self) -> Result<(), ConstraintError> { if let Some(ref value) = self.description { #[allow(unused_comparisons)] if ::len(value.as_ref()) > 10240usize { return Err(ConstraintError::MaxLength { path: ValidationPath::from_field("description"), max: 10240usize, actual: ::len(value.as_ref()), }); } } if let Some(ref value) = self.description { { let count = UnicodeSegmentation::graphemes(value.as_ref(), true).count(); if count > 1024usize { return Err(ConstraintError::MaxGraphemes { path: ValidationPath::from_field("description"), max: 1024usize, actual: count, }); } } } { let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) > 128usize { return Err(ConstraintError::MaxLength { path: ValidationPath::from_field("name"), max: 128usize, actual: ::len(value.as_ref()), }); } } { let value = &self.name; #[allow(unused_comparisons)] if ::len(value.as_ref()) < 3usize { return Err(ConstraintError::MinLength { path: ValidationPath::from_field("name"), min: 3usize, actual: ::len(value.as_ref()), }); } } Ok(()) } } fn lexicon_doc_tools_ozone_set_defs() -> 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("tools.ozone.set.defs"), defs: { let mut map = BTreeMap::new(); map.insert( SmolStr::new_static("set"), LexUserType::Object(LexObject { required: Some(vec![SmolStr::new_static("name")]), properties: { #[allow(unused_mut)] let mut map = BTreeMap::new(); map.insert( SmolStr::new_static("description"), LexObjectProperty::String(LexString { max_length: Some(10240usize), max_graphemes: Some(1024usize), ..Default::default() }), ); map.insert( SmolStr::new_static("name"), LexObjectProperty::String(LexString { min_length: Some(3usize), max_length: Some(128usize), ..Default::default() }), ); map }, ..Default::default() }), ); map.insert( SmolStr::new_static("setView"), LexUserType::Object(LexObject { required: Some( vec![ SmolStr::new_static("name"), SmolStr::new_static("setSize"), SmolStr::new_static("createdAt"), SmolStr::new_static("updatedAt") ], ), 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("description"), LexObjectProperty::String(LexString { max_length: Some(10240usize), max_graphemes: Some(1024usize), ..Default::default() }), ); map.insert( SmolStr::new_static("name"), LexObjectProperty::String(LexString { min_length: Some(3usize), max_length: Some(128usize), ..Default::default() }), ); map.insert( SmolStr::new_static("setSize"), LexObjectProperty::Integer(LexInteger { ..Default::default() }), ); map.insert( SmolStr::new_static("updatedAt"), LexObjectProperty::String(LexString { format: Some(LexStringFormat::Datetime), ..Default::default() }), ); map }, ..Default::default() }), ); map }, ..Default::default() } } pub mod set_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 Name; type CreatedAt; type SetSize; type UpdatedAt; } /// Empty state - all required fields are unset pub struct Empty(()); impl sealed::Sealed for Empty {} impl State for Empty { type Name = Unset; type CreatedAt = Unset; type SetSize = Unset; type UpdatedAt = Unset; } ///State transition - sets the `name` field to Set pub struct SetName(PhantomData S>); impl sealed::Sealed for SetName {} impl State for SetName { type Name = Set; type CreatedAt = S::CreatedAt; type SetSize = S::SetSize; type UpdatedAt = S::UpdatedAt; } ///State transition - sets the `created_at` field to Set pub struct SetCreatedAt(PhantomData S>); impl sealed::Sealed for SetCreatedAt {} impl State for SetCreatedAt { type Name = S::Name; type CreatedAt = Set; type SetSize = S::SetSize; type UpdatedAt = S::UpdatedAt; } ///State transition - sets the `set_size` field to Set pub struct SetSetSize(PhantomData S>); impl sealed::Sealed for SetSetSize {} impl State for SetSetSize { type Name = S::Name; type CreatedAt = S::CreatedAt; type SetSize = Set; type UpdatedAt = S::UpdatedAt; } ///State transition - sets the `updated_at` field to Set pub struct SetUpdatedAt(PhantomData S>); impl sealed::Sealed for SetUpdatedAt {} impl State for SetUpdatedAt { type Name = S::Name; type CreatedAt = S::CreatedAt; type SetSize = S::SetSize; type UpdatedAt = Set; } /// Marker types for field names #[allow(non_camel_case_types)] pub mod members { ///Marker type for the `name` field pub struct name(()); ///Marker type for the `created_at` field pub struct created_at(()); ///Marker type for the `set_size` field pub struct set_size(()); ///Marker type for the `updated_at` field pub struct updated_at(()); } } /// Builder for constructing an instance of this type pub struct SetViewBuilder<'a, S: set_view_state::State> { _state: PhantomData S>, _fields: ( Option, Option>, Option>, Option, Option, ), _lifetime: PhantomData<&'a ()>, } impl<'a> SetView<'a> { /// Create a new builder for this type pub fn new() -> SetViewBuilder<'a, set_view_state::Empty> { SetViewBuilder::new() } } impl<'a> SetViewBuilder<'a, set_view_state::Empty> { /// Create a new builder with all fields unset pub fn new() -> Self { SetViewBuilder { _state: PhantomData, _fields: (None, None, None, None, None), _lifetime: PhantomData, } } } impl<'a, S> SetViewBuilder<'a, S> where S: set_view_state::State, S::CreatedAt: set_view_state::IsUnset, { /// Set the `createdAt` field (required) pub fn created_at( mut self, value: impl Into, ) -> SetViewBuilder<'a, set_view_state::SetCreatedAt> { self._fields.0 = Option::Some(value.into()); SetViewBuilder { _state: PhantomData, _fields: self._fields, _lifetime: PhantomData, } } } impl<'a, S: set_view_state::State> SetViewBuilder<'a, S> { /// Set the `description` field (optional) pub fn description(mut self, value: impl Into>>) -> Self { self._fields.1 = value.into(); self } /// Set the `description` field to an Option value (optional) pub fn maybe_description(mut self, value: Option>) -> Self { self._fields.1 = value; self } } impl<'a, S> SetViewBuilder<'a, S> where S: set_view_state::State, S::Name: set_view_state::IsUnset, { /// Set the `name` field (required) pub fn name( mut self, value: impl Into>, ) -> SetViewBuilder<'a, set_view_state::SetName> { self._fields.2 = Option::Some(value.into()); SetViewBuilder { _state: PhantomData, _fields: self._fields, _lifetime: PhantomData, } } } impl<'a, S> SetViewBuilder<'a, S> where S: set_view_state::State, S::SetSize: set_view_state::IsUnset, { /// Set the `setSize` field (required) pub fn set_size( mut self, value: impl Into, ) -> SetViewBuilder<'a, set_view_state::SetSetSize> { self._fields.3 = Option::Some(value.into()); SetViewBuilder { _state: PhantomData, _fields: self._fields, _lifetime: PhantomData, } } } impl<'a, S> SetViewBuilder<'a, S> where S: set_view_state::State, S::UpdatedAt: set_view_state::IsUnset, { /// Set the `updatedAt` field (required) pub fn updated_at( mut self, value: impl Into, ) -> SetViewBuilder<'a, set_view_state::SetUpdatedAt> { self._fields.4 = Option::Some(value.into()); SetViewBuilder { _state: PhantomData, _fields: self._fields, _lifetime: PhantomData, } } } impl<'a, S> SetViewBuilder<'a, S> where S: set_view_state::State, S::Name: set_view_state::IsSet, S::CreatedAt: set_view_state::IsSet, S::SetSize: set_view_state::IsSet, S::UpdatedAt: set_view_state::IsSet, { /// Build the final struct pub fn build(self) -> SetView<'a> { SetView { created_at: self._fields.0.unwrap(), description: self._fields.1, name: self._fields.2.unwrap(), set_size: self._fields.3.unwrap(), updated_at: 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< jacquard_common::deps::smol_str::SmolStr, jacquard_common::types::value::Data<'a>, >, ) -> SetView<'a> { SetView { created_at: self._fields.0.unwrap(), description: self._fields.1, name: self._fields.2.unwrap(), set_size: self._fields.3.unwrap(), updated_at: self._fields.4.unwrap(), extra_data: Some(extra_data), } } }