// @generated by jacquard-lexicon. DO NOT EDIT.
//
// Lexicon: net.anisota.lab.petri
//
// 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::{BosStr, CowStr, 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::{Deserialize, Serialize};
/// A petri culture grown in the Anisota Lab's Petri studio and saved to the owner's collection. A culture is stored as its recipe rather than its pixels: a 'seed', the dish dimensions, and the ordered list of 'drops' (each an ingredient inoculated at a normalised point and at a given iteration). Because the Gray-Scott reaction-diffusion simulation is deterministic, replaying that recipe rebuilds the exact field. 'iterations' is how far the culture has grown; 'lastTickAt' lets a reopened culture advance proportionally to real time elapsed. A small PNG thumbnail is kept for display.
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(
rename_all = "camelCase",
rename = "net.anisota.lab.petri",
tag = "$type",
bound(deserialize = "S: Deserialize<'de> + BosStr")
)]
pub struct Petri<S: BosStr = DefaultStr> {
///Form tunable 'branching' (dense blob → open dendrites → veins), scaled 0..1000
#[serde(skip_serializing_if = "Option::is_none")]
pub branch: Option<i64>,
///When the culture was saved
pub created_at: Datetime,
///Ordered inoculations: each an ingredient placed at a normalised point at a given iteration
pub drops: Vec<Data<S>>,
///Dish grid height in cells
pub height: i64,
///A PNG data URL thumbnail of the culture
#[serde(skip_serializing_if = "Option::is_none")]
pub image: Option<S>,
///How many simulation iterations the culture has grown
pub iterations: i64,
///When the culture last advanced, used to grow it forward on reopen
#[serde(skip_serializing_if = "Option::is_none")]
pub last_tick_at: Option<Datetime>,
///Display name for the culture
pub name: S,
///Colour palette id (agar, rose, amber, marine)
#[serde(skip_serializing_if = "Option::is_none")]
pub palette: Option<S>,
///PRNG seed the simulation was initialised with
pub seed: i64,
///Form tunable 'thickness' (fine veins → fat rivulets), scaled 0..1000
#[serde(skip_serializing_if = "Option::is_none")]
pub thickness: Option<i64>,
///Form tunable 'wander' (straight → meandering branches), scaled 0..1000
#[serde(skip_serializing_if = "Option::is_none")]
pub wander: Option<i64>,
///Dish grid width in cells
pub width: i64,
#[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 PetriGetRecordOutput<S: BosStr = DefaultStr> {
#[serde(skip_serializing_if = "Option::is_none")]
pub cid: Option<Cid<S>>,
pub uri: AtUri<S>,
pub value: Petri<S>,
}
impl<S: BosStr> Petri<S> {
pub fn uri(uri: S) -> Result<RecordUri<S, PetriRecord>, UriError> {
RecordUri::try_from_uri(AtUri::new(uri)?)
}
}
/// Marker type for deserializing records from this collection.
#[derive(Debug, Serialize, Deserialize)]
pub struct PetriRecord;
impl XrpcResp for PetriRecord {
const NSID: &'static str = "net.anisota.lab.petri";
const ENCODING: &'static str = "application/json";
type Output<S: BosStr> = PetriGetRecordOutput<S>;
type Err = RecordError;
}
impl<S: BosStr> From<PetriGetRecordOutput<S>> for Petri<S> {
fn from(output: PetriGetRecordOutput<S>) -> Self {
output.value
}
}
impl<S: BosStr> Collection for Petri<S> {
const NSID: &'static str = "net.anisota.lab.petri";
type Record = PetriRecord;
}
impl Collection for PetriRecord {
const NSID: &'static str = "net.anisota.lab.petri";
type Record = PetriRecord;
}
impl<S: BosStr> LexiconSchema for Petri<S> {
fn nsid() -> &'static str {
"net.anisota.lab.petri"
}
fn def_name() -> &'static str {
"main"
}
fn lexicon_doc() -> LexiconDoc<'static> {
lexicon_doc_net_anisota_lab_petri()
}
fn validate(&self) -> Result<(), ConstraintError> {
{
let value = &self.drops;
#[allow(unused_comparisons)]
if value.len() > 512usize {
return Err(ConstraintError::MaxLength {
path: ValidationPath::from_field("drops"),
max: 512usize,
actual: value.len(),
});
}
}
if let Some(ref value) = self.image {
#[allow(unused_comparisons)]
if <str>::len(value.as_ref()) > 120000usize {
return Err(ConstraintError::MaxLength {
path: ValidationPath::from_field("image"),
max: 120000usize,
actual: <str>::len(value.as_ref()),
});
}
}
{
let value = &self.name;
#[allow(unused_comparisons)]
if <str>::len(value.as_ref()) > 800usize {
return Err(ConstraintError::MaxLength {
path: ValidationPath::from_field("name"),
max: 800usize,
actual: <str>::len(value.as_ref()),
});
}
}
{
let value = &self.name;
{
let count = UnicodeSegmentation::graphemes(value.as_ref(), true).count();
if count > 100usize {
return Err(ConstraintError::MaxGraphemes {
path: ValidationPath::from_field("name"),
max: 100usize,
actual: count,
});
}
}
}
if let Some(ref value) = self.palette {
#[allow(unused_comparisons)]
if <str>::len(value.as_ref()) > 40usize {
return Err(ConstraintError::MaxLength {
path: ValidationPath::from_field("palette"),
max: 40usize,
actual: <str>::len(value.as_ref()),
});
}
}
Ok(())
}
}
pub mod petri_state {
pub use crate::builder_types::{IsSet, IsUnset, Set, Unset};
#[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 Drops;
type Height;
type Iterations;
type Name;
type Seed;
type Width;
}
/// Empty state - all required fields are unset
pub struct Empty(());
impl sealed::Sealed for Empty {}
impl State for Empty {
type CreatedAt = Unset;
type Drops = Unset;
type Height = Unset;
type Iterations = Unset;
type Name = Unset;
type Seed = Unset;
type Width = 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 Drops = St::Drops;
type Height = St::Height;
type Iterations = St::Iterations;
type Name = St::Name;
type Seed = St::Seed;
type Width = St::Width;
}
///State transition - sets the `drops` field to Set
pub struct SetDrops<St: State = Empty>(PhantomData<fn() -> St>);
impl<St: State> sealed::Sealed for SetDrops<St> {}
impl<St: State> State for SetDrops<St> {
type CreatedAt = St::CreatedAt;
type Drops = Set<members::drops>;
type Height = St::Height;
type Iterations = St::Iterations;
type Name = St::Name;
type Seed = St::Seed;
type Width = St::Width;
}
///State transition - sets the `height` field to Set
pub struct SetHeight<St: State = Empty>(PhantomData<fn() -> St>);
impl<St: State> sealed::Sealed for SetHeight<St> {}
impl<St: State> State for SetHeight<St> {
type CreatedAt = St::CreatedAt;
type Drops = St::Drops;
type Height = Set<members::height>;
type Iterations = St::Iterations;
type Name = St::Name;
type Seed = St::Seed;
type Width = St::Width;
}
///State transition - sets the `iterations` field to Set
pub struct SetIterations<St: State = Empty>(PhantomData<fn() -> St>);
impl<St: State> sealed::Sealed for SetIterations<St> {}
impl<St: State> State for SetIterations<St> {
type CreatedAt = St::CreatedAt;
type Drops = St::Drops;
type Height = St::Height;
type Iterations = Set<members::iterations>;
type Name = St::Name;
type Seed = St::Seed;
type Width = St::Width;
}
///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 Drops = St::Drops;
type Height = St::Height;
type Iterations = St::Iterations;
type Name = Set<members::name>;
type Seed = St::Seed;
type Width = St::Width;
}
///State transition - sets the `seed` field to Set
pub struct SetSeed<St: State = Empty>(PhantomData<fn() -> St>);
impl<St: State> sealed::Sealed for SetSeed<St> {}
impl<St: State> State for SetSeed<St> {
type CreatedAt = St::CreatedAt;
type Drops = St::Drops;
type Height = St::Height;
type Iterations = St::Iterations;
type Name = St::Name;
type Seed = Set<members::seed>;
type Width = St::Width;
}
///State transition - sets the `width` field to Set
pub struct SetWidth<St: State = Empty>(PhantomData<fn() -> St>);
impl<St: State> sealed::Sealed for SetWidth<St> {}
impl<St: State> State for SetWidth<St> {
type CreatedAt = St::CreatedAt;
type Drops = St::Drops;
type Height = St::Height;
type Iterations = St::Iterations;
type Name = St::Name;
type Seed = St::Seed;
type Width = Set<members::width>;
}
/// 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 `drops` field
pub struct drops(());
///Marker type for the `height` field
pub struct height(());
///Marker type for the `iterations` field
pub struct iterations(());
///Marker type for the `name` field
pub struct name(());
///Marker type for the `seed` field
pub struct seed(());
///Marker type for the `width` field
pub struct width(());
}
}
/// Builder for constructing an instance of this type.
pub struct PetriBuilder<St: petri_state::State, S: BosStr = DefaultStr> {
_state: PhantomData<fn() -> St>,
_fields: (
Option<i64>,
Option<Datetime>,
Option<Vec<Data<S>>>,
Option<i64>,
Option<S>,
Option<i64>,
Option<Datetime>,
Option<S>,
Option<S>,
Option<i64>,
Option<i64>,
Option<i64>,
Option<i64>,
),
_type: PhantomData<fn() -> S>,
}
impl Petri<DefaultStr> {
/// Create a new builder for this type, using the default string type (DefaultStr = SmolStr) if needed
pub fn new() -> PetriBuilder<petri_state::Empty, DefaultStr> {
PetriBuilder::new()
}
}
impl<S: BosStr> Petri<S> {
/// Create a new builder for this type
pub fn builder() -> PetriBuilder<petri_state::Empty, S> {
PetriBuilder::builder()
}
}
impl PetriBuilder<petri_state::Empty, DefaultStr> {
/// Create a new builder with all fields unset, using the default string type, if needed
pub fn new() -> Self {
PetriBuilder {
_state: PhantomData,
_fields: (
None, None, None, None, None, None, None, None, None, None, None, None, None,
),
_type: PhantomData,
}
}
}
impl<S: BosStr> PetriBuilder<petri_state::Empty, S> {
/// Create a new builder with all fields unset
pub fn builder() -> Self {
PetriBuilder {
_state: PhantomData,
_fields: (
None, None, None, None, None, None, None, None, None, None, None, None, None,
),
_type: PhantomData,
}
}
}
impl<St: petri_state::State, S: BosStr> PetriBuilder<St, S> {
/// Set the `branch` field (optional)
pub fn branch(mut self, value: impl Into<Option<i64>>) -> Self {
self._fields.0 = value.into();
self
}
/// Set the `branch` field to an Option value (optional)
pub fn maybe_branch(mut self, value: Option<i64>) -> Self {
self._fields.0 = value;
self
}
}
impl<St, S: BosStr> PetriBuilder<St, S>
where
St: petri_state::State,
St::CreatedAt: petri_state::IsUnset,
{
/// Set the `createdAt` field (required)
pub fn created_at(
mut self,
value: impl Into<Datetime>,
) -> PetriBuilder<petri_state::SetCreatedAt<St>, S> {
self._fields.1 = Option::Some(value.into());
PetriBuilder {
_state: PhantomData,
_fields: self._fields,
_type: PhantomData,
}
}
}
impl<St, S: BosStr> PetriBuilder<St, S>
where
St: petri_state::State,
St::Drops: petri_state::IsUnset,
{
/// Set the `drops` field (required)
pub fn drops(
mut self,
value: impl Into<Vec<Data<S>>>,
) -> PetriBuilder<petri_state::SetDrops<St>, S> {
self._fields.2 = Option::Some(value.into());
PetriBuilder {
_state: PhantomData,
_fields: self._fields,
_type: PhantomData,
}
}
}
impl<St, S: BosStr> PetriBuilder<St, S>
where
St: petri_state::State,
St::Height: petri_state::IsUnset,
{
/// Set the `height` field (required)
pub fn height(mut self, value: impl Into<i64>) -> PetriBuilder<petri_state::SetHeight<St>, S> {
self._fields.3 = Option::Some(value.into());
PetriBuilder {
_state: PhantomData,
_fields: self._fields,
_type: PhantomData,
}
}
}
impl<St: petri_state::State, S: BosStr> PetriBuilder<St, S> {
/// Set the `image` field (optional)
pub fn image(mut self, value: impl Into<Option<S>>) -> Self {
self._fields.4 = value.into();
self
}
/// Set the `image` field to an Option value (optional)
pub fn maybe_image(mut self, value: Option<S>) -> Self {
self._fields.4 = value;
self
}
}
impl<St, S: BosStr> PetriBuilder<St, S>
where
St: petri_state::State,
St::Iterations: petri_state::IsUnset,
{
/// Set the `iterations` field (required)
pub fn iterations(
mut self,
value: impl Into<i64>,
) -> PetriBuilder<petri_state::SetIterations<St>, S> {
self._fields.5 = Option::Some(value.into());
PetriBuilder {
_state: PhantomData,
_fields: self._fields,
_type: PhantomData,
}
}
}
impl<St: petri_state::State, S: BosStr> PetriBuilder<St, S> {
/// Set the `lastTickAt` field (optional)
pub fn last_tick_at(mut self, value: impl Into<Option<Datetime>>) -> Self {
self._fields.6 = value.into();
self
}
/// Set the `lastTickAt` field to an Option value (optional)
pub fn maybe_last_tick_at(mut self, value: Option<Datetime>) -> Self {
self._fields.6 = value;
self
}
}
impl<St, S: BosStr> PetriBuilder<St, S>
where
St: petri_state::State,
St::Name: petri_state::IsUnset,
{
/// Set the `name` field (required)
pub fn name(mut self, value: impl Into<S>) -> PetriBuilder<petri_state::SetName<St>, S> {
self._fields.7 = Option::Some(value.into());
PetriBuilder {
_state: PhantomData,
_fields: self._fields,
_type: PhantomData,
}
}
}
impl<St: petri_state::State, S: BosStr> PetriBuilder<St, S> {
/// Set the `palette` field (optional)
pub fn palette(mut self, value: impl Into<Option<S>>) -> Self {
self._fields.8 = value.into();
self
}
/// Set the `palette` field to an Option value (optional)
pub fn maybe_palette(mut self, value: Option<S>) -> Self {
self._fields.8 = value;
self
}
}
impl<St, S: BosStr> PetriBuilder<St, S>
where
St: petri_state::State,
St::Seed: petri_state::IsUnset,
{
/// Set the `seed` field (required)
pub fn seed(mut self, value: impl Into<i64>) -> PetriBuilder<petri_state::SetSeed<St>, S> {
self._fields.9 = Option::Some(value.into());
PetriBuilder {
_state: PhantomData,
_fields: self._fields,
_type: PhantomData,
}
}
}
impl<St: petri_state::State, S: BosStr> PetriBuilder<St, S> {
/// Set the `thickness` field (optional)
pub fn thickness(mut self, value: impl Into<Option<i64>>) -> Self {
self._fields.10 = value.into();
self
}
/// Set the `thickness` field to an Option value (optional)
pub fn maybe_thickness(mut self, value: Option<i64>) -> Self {
self._fields.10 = value;
self
}
}
impl<St: petri_state::State, S: BosStr> PetriBuilder<St, S> {
/// Set the `wander` field (optional)
pub fn wander(mut self, value: impl Into<Option<i64>>) -> Self {
self._fields.11 = value.into();
self
}
/// Set the `wander` field to an Option value (optional)
pub fn maybe_wander(mut self, value: Option<i64>) -> Self {
self._fields.11 = value;
self
}
}
impl<St, S: BosStr> PetriBuilder<St, S>
where
St: petri_state::State,
St::Width: petri_state::IsUnset,
{
/// Set the `width` field (required)
pub fn width(mut self, value: impl Into<i64>) -> PetriBuilder<petri_state::SetWidth<St>, S> {
self._fields.12 = Option::Some(value.into());
PetriBuilder {
_state: PhantomData,
_fields: self._fields,
_type: PhantomData,
}
}
}
impl<St, S: BosStr> PetriBuilder<St, S>
where
St: petri_state::State,
St::CreatedAt: petri_state::IsSet,
St::Drops: petri_state::IsSet,
St::Height: petri_state::IsSet,
St::Iterations: petri_state::IsSet,
St::Name: petri_state::IsSet,
St::Seed: petri_state::IsSet,
St::Width: petri_state::IsSet,
{
/// Build the final struct.
pub fn build(self) -> Petri<S> {
Petri {
branch: self._fields.0,
created_at: self._fields.1.unwrap(),
drops: self._fields.2.unwrap(),
height: self._fields.3.unwrap(),
image: self._fields.4,
iterations: self._fields.5.unwrap(),
last_tick_at: self._fields.6,
name: self._fields.7.unwrap(),
palette: self._fields.8,
seed: self._fields.9.unwrap(),
thickness: self._fields.10,
wander: self._fields.11,
width: self._fields.12.unwrap(),
extra_data: Default::default(),
}
}
/// Build the final struct with custom extra_data.
pub fn build_with_data(self, extra_data: BTreeMap<SmolStr, Data<S>>) -> Petri<S> {
Petri {
branch: self._fields.0,
created_at: self._fields.1.unwrap(),
drops: self._fields.2.unwrap(),
height: self._fields.3.unwrap(),
image: self._fields.4,
iterations: self._fields.5.unwrap(),
last_tick_at: self._fields.6,
name: self._fields.7.unwrap(),
palette: self._fields.8,
seed: self._fields.9.unwrap(),
thickness: self._fields.10,
wander: self._fields.11,
width: self._fields.12.unwrap(),
extra_data: Some(extra_data),
}
}
}
fn lexicon_doc_net_anisota_lab_petri() -> LexiconDoc<'static> {
use alloc::collections::BTreeMap;
#[allow(unused_imports)]
use jacquard_common::{CowStr, deps::smol_str::SmolStr, types::blob::MimeType};
use jacquard_lexicon::lexicon::*;
LexiconDoc {
lexicon: Lexicon::Lexicon1,
id: CowStr::new_static("net.anisota.lab.petri"),
defs: {
let mut map = BTreeMap::new();
map.insert(
SmolStr::new_static("main"),
LexUserType::Record(LexRecord {
description: Some(
CowStr::new_static(
"A petri culture grown in the Anisota Lab's Petri studio and saved to the owner's collection. A culture is stored as its recipe rather than its pixels: a 'seed', the dish dimensions, and the ordered list of 'drops' (each an ingredient inoculated at a normalised point and at a given iteration). Because the Gray-Scott reaction-diffusion simulation is deterministic, replaying that recipe rebuilds the exact field. 'iterations' is how far the culture has grown; 'lastTickAt' lets a reopened culture advance proportionally to real time elapsed. A small PNG thumbnail is kept for display.",
),
),
key: Some(CowStr::new_static("any")),
record: LexRecordRecord::Object(LexObject {
required: Some(
vec![
SmolStr::new_static("name"), SmolStr::new_static("seed"),
SmolStr::new_static("width"), SmolStr::new_static("height"),
SmolStr::new_static("drops"),
SmolStr::new_static("iterations"),
SmolStr::new_static("createdAt")
],
),
properties: {
#[allow(unused_mut)]
let mut map = BTreeMap::new();
map.insert(
SmolStr::new_static("branch"),
LexObjectProperty::Integer(LexInteger {
..Default::default()
}),
);
map.insert(
SmolStr::new_static("createdAt"),
LexObjectProperty::String(LexString {
description: Some(
CowStr::new_static("When the culture was saved"),
),
format: Some(LexStringFormat::Datetime),
..Default::default()
}),
);
map.insert(
SmolStr::new_static("drops"),
LexObjectProperty::Array(LexArray {
description: Some(
CowStr::new_static(
"Ordered inoculations: each an ingredient placed at a normalised point at a given iteration",
),
),
items: LexArrayItem::Object(LexObject {
required: Some(
vec![
SmolStr::new_static("ingredient"), SmolStr::new_static("x"),
SmolStr::new_static("y"), SmolStr::new_static("atIteration")
],
),
properties: {
#[allow(unused_mut)]
let mut map = BTreeMap::new();
map.insert(
SmolStr::new_static("atIteration"),
LexObjectProperty::Integer(LexInteger {
..Default::default()
}),
);
map.insert(
SmolStr::new_static("ingredient"),
LexObjectProperty::String(LexString {
description: Some(
CowStr::new_static(
"Ingredient id (bacillus, mold, yeast, pigment, agar, antibiotic)",
),
),
max_length: Some(40usize),
..Default::default()
}),
);
map.insert(
SmolStr::new_static("r"),
LexObjectProperty::Integer(LexInteger {
..Default::default()
}),
);
map.insert(
SmolStr::new_static("tint"),
LexObjectProperty::Integer(LexInteger {
..Default::default()
}),
);
map.insert(
SmolStr::new_static("x"),
LexObjectProperty::Integer(LexInteger {
..Default::default()
}),
);
map.insert(
SmolStr::new_static("y"),
LexObjectProperty::Integer(LexInteger {
..Default::default()
}),
);
map
},
..Default::default()
}),
max_length: Some(512usize),
..Default::default()
}),
);
map.insert(
SmolStr::new_static("height"),
LexObjectProperty::Integer(LexInteger {
..Default::default()
}),
);
map.insert(
SmolStr::new_static("image"),
LexObjectProperty::String(LexString {
description: Some(
CowStr::new_static(
"A PNG data URL thumbnail of the culture",
),
),
max_length: Some(120000usize),
..Default::default()
}),
);
map.insert(
SmolStr::new_static("iterations"),
LexObjectProperty::Integer(LexInteger {
..Default::default()
}),
);
map.insert(
SmolStr::new_static("lastTickAt"),
LexObjectProperty::String(LexString {
description: Some(
CowStr::new_static(
"When the culture last advanced, used to grow it forward on reopen",
),
),
format: Some(LexStringFormat::Datetime),
..Default::default()
}),
);
map.insert(
SmolStr::new_static("name"),
LexObjectProperty::String(LexString {
description: Some(
CowStr::new_static("Display name for the culture"),
),
max_length: Some(800usize),
max_graphemes: Some(100usize),
..Default::default()
}),
);
map.insert(
SmolStr::new_static("palette"),
LexObjectProperty::String(LexString {
description: Some(
CowStr::new_static(
"Colour palette id (agar, rose, amber, marine)",
),
),
max_length: Some(40usize),
..Default::default()
}),
);
map.insert(
SmolStr::new_static("seed"),
LexObjectProperty::Integer(LexInteger {
..Default::default()
}),
);
map.insert(
SmolStr::new_static("thickness"),
LexObjectProperty::Integer(LexInteger {
..Default::default()
}),
);
map.insert(
SmolStr::new_static("wander"),
LexObjectProperty::Integer(LexInteger {
..Default::default()
}),
);
map.insert(
SmolStr::new_static("width"),
LexObjectProperty::Integer(LexInteger {
..Default::default()
}),
);
map
},
..Default::default()
}),
..Default::default()
}),
);
map
},
..Default::default()
}
}