// @generated by jacquard-lexicon. DO NOT EDIT.
//
// Lexicon: net.anisota.observatory.layout
//
// 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, Did, Handle};
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;
use crate::net_anisota::observatory::layout;
#[allow(unused_imports)]
use jacquard_lexicon::validation::{ConstraintError, ValidationPath};
use serde::{Deserialize, Serialize};
/// Attribution for the original crafter of this layout.
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
#[serde(
rename_all = "camelCase",
bound(deserialize = "S: Deserialize<'de> + BosStr")
)]
pub struct CreatedBy<S: BosStr = DefaultStr> {
#[serde(skip_serializing_if = "Option::is_none")]
pub did: Option<Did<S>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub handle: Option<Handle<S>>,
#[serde(flatten, default, skip_serializing_if = "Option::is_none")]
pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,
}
/// The grid configuration captured by this layout.
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
#[serde(
rename_all = "camelCase",
bound(deserialize = "S: Deserialize<'de> + BosStr")
)]
pub struct Layout<S: BosStr = DefaultStr> {
///Built-in button overrides keyed by button key (enter, atmosphere, post, chronicle, inventory, harvest, tutorial). Each value may carry enabled, order, size, and variant.
#[serde(skip_serializing_if = "Option::is_none")]
pub buttons: Option<Data<S>>,
///Patterns visualization configuration captured with this layout
#[serde(skip_serializing_if = "Option::is_none")]
pub patterns_indicator: Option<Data<S>>,
///Whether tiles shuffle within divider-bounded groups each session
#[serde(skip_serializing_if = "Option::is_none")]
pub shuffle_layout: Option<bool>,
///Unified rendering order. Entries are 'builtin:<key>' or 'element:<index>' into the record's elements array.
#[serde(skip_serializing_if = "Option::is_none")]
pub tile_order: Option<Vec<S>>,
#[serde(flatten, default, skip_serializing_if = "Option::is_none")]
pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,
}
/// A saved Observatory grid layout. Each record is a complete, self-contained snapshot of a layout — built-in button configuration, unified tile order, and embedded element snapshots — so it can be shared by URL and saved ('learned') into another user's PDS without depending on the original author's element records, mirroring the spell architecture. tileOrder entries are 'builtin:<key>' for built-in tiles or 'element:<index>' pointing into the embedded elements array. An optional schedule makes the layout activate automatically during a daily time window.
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(
rename_all = "camelCase",
rename = "net.anisota.observatory.layout",
tag = "$type",
bound(deserialize = "S: Deserialize<'de> + BosStr")
)]
pub struct LayoutRecord<S: BosStr = DefaultStr> {
///When this layout was first saved
pub created_at: Datetime,
#[serde(skip_serializing_if = "Option::is_none")]
pub created_by: Option<layout::CreatedBy<S>>,
///Optional description of what this layout is for
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<S>,
///Embedded snapshots of the custom elements this layout uses. Each entry mirrors the shape of a net.anisota.observatory.element record body (type, name, description, plus the type-specific payload: button, note, quote, reminder, divider, spacer, heading, or widget).
#[serde(skip_serializing_if = "Option::is_none")]
pub elements: Option<Vec<Data<S>>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub layout: Option<layout::Layout<S>>,
///Display name for this layout
pub name: S,
#[serde(skip_serializing_if = "Option::is_none")]
pub schedule: Option<layout::Schedule<S>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub source: Option<layout::Source<S>>,
///When this layout was last modified
pub updated_at: Datetime,
#[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 LayoutRecordGetRecordOutput<S: BosStr = DefaultStr> {
#[serde(skip_serializing_if = "Option::is_none")]
pub cid: Option<Cid<S>>,
pub uri: AtUri<S>,
pub value: LayoutRecord<S>,
}
/// Optional daily activation window. When enabled, the layout takes over the Observatory between startTime and endTime (wrapping past midnight when startTime > endTime), optionally restricted to certain days of the week.
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
#[serde(
rename_all = "camelCase",
bound(deserialize = "S: Deserialize<'de> + BosStr")
)]
pub struct Schedule<S: BosStr = DefaultStr> {
///Days the window applies to (0 = Sunday … 6 = Saturday). Empty or absent means every day.
#[serde(skip_serializing_if = "Option::is_none")]
pub days_of_week: Option<Vec<i64>>,
///Whether the schedule is active
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
///Window end as 'HH:MM' (24-hour, local time)
#[serde(skip_serializing_if = "Option::is_none")]
pub end_time: Option<S>,
///Window start as 'HH:MM' (24-hour, local time)
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time: Option<S>,
#[serde(flatten, default, skip_serializing_if = "Option::is_none")]
pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,
}
/// Provenance backlink for layouts learned from another user.
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
#[serde(
rename_all = "camelCase",
bound(deserialize = "S: Deserialize<'de> + BosStr")
)]
pub struct Source<S: BosStr = DefaultStr> {
///DID of the user this layout was learned from
#[serde(skip_serializing_if = "Option::is_none")]
pub original_did: Option<Did<S>>,
///AT URI of the record this layout was learned from
#[serde(skip_serializing_if = "Option::is_none")]
pub original_uri: Option<AtUri<S>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub r#type: Option<SourceType<S>>,
#[serde(flatten, default, skip_serializing_if = "Option::is_none")]
pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum SourceType<S: BosStr = DefaultStr> {
Original,
Learned,
Other(S),
}
impl<S: BosStr> SourceType<S> {
pub fn as_str(&self) -> &str {
match self {
Self::Original => "original",
Self::Learned => "learned",
Self::Other(s) => s.as_ref(),
}
}
/// Construct from a string-like value, matching known values.
pub fn from_value(s: S) -> Self {
match s.as_ref() {
"original" => Self::Original,
"learned" => Self::Learned,
_ => Self::Other(s),
}
}
}
impl<S: BosStr> core::fmt::Display for SourceType<S> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "{}", self.as_str())
}
}
impl<S: BosStr> AsRef<str> for SourceType<S> {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl<S: BosStr> Serialize for SourceType<S> {
fn serialize<Ser>(&self, serializer: Ser) -> Result<Ser::Ok, Ser::Error>
where
Ser: serde::Serializer,
{
serializer.serialize_str(self.as_str())
}
}
impl<'de, S: Deserialize<'de> + BosStr> Deserialize<'de> for SourceType<S> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let s = S::deserialize(deserializer)?;
Ok(Self::from_value(s))
}
}
impl<S: BosStr + Default> Default for SourceType<S> {
fn default() -> Self {
Self::Other(Default::default())
}
}
impl<S: BosStr> jacquard_common::IntoStatic for SourceType<S>
where
S: BosStr + jacquard_common::IntoStatic,
S::Output: BosStr,
{
type Output = SourceType<S::Output>;
fn into_static(self) -> Self::Output {
match self {
SourceType::Original => SourceType::Original,
SourceType::Learned => SourceType::Learned,
SourceType::Other(v) => SourceType::Other(v.into_static()),
}
}
}
impl<S: BosStr> LayoutRecord<S> {
pub fn uri(uri: S) -> Result<RecordUri<S, LayoutRecordRecord>, UriError> {
RecordUri::try_from_uri(AtUri::new(uri)?)
}
}
impl<S: BosStr> LexiconSchema for CreatedBy<S> {
fn nsid() -> &'static str {
"net.anisota.observatory.layout"
}
fn def_name() -> &'static str {
"createdBy"
}
fn lexicon_doc() -> LexiconDoc<'static> {
lexicon_doc_net_anisota_observatory_layout()
}
fn validate(&self) -> Result<(), ConstraintError> {
Ok(())
}
}
impl<S: BosStr> LexiconSchema for Layout<S> {
fn nsid() -> &'static str {
"net.anisota.observatory.layout"
}
fn def_name() -> &'static str {
"layout"
}
fn lexicon_doc() -> LexiconDoc<'static> {
lexicon_doc_net_anisota_observatory_layout()
}
fn validate(&self) -> Result<(), ConstraintError> {
Ok(())
}
}
/// Marker type for deserializing records from this collection.
#[derive(Debug, Serialize, Deserialize)]
pub struct LayoutRecordRecord;
impl XrpcResp for LayoutRecordRecord {
const NSID: &'static str = "net.anisota.observatory.layout";
const ENCODING: &'static str = "application/json";
type Output<S: BosStr> = LayoutRecordGetRecordOutput<S>;
type Err = RecordError;
}
impl<S: BosStr> From<LayoutRecordGetRecordOutput<S>> for LayoutRecord<S> {
fn from(output: LayoutRecordGetRecordOutput<S>) -> Self {
output.value
}
}
impl<S: BosStr> Collection for LayoutRecord<S> {
const NSID: &'static str = "net.anisota.observatory.layout";
type Record = LayoutRecordRecord;
}
impl Collection for LayoutRecordRecord {
const NSID: &'static str = "net.anisota.observatory.layout";
type Record = LayoutRecordRecord;
}
impl<S: BosStr> LexiconSchema for LayoutRecord<S> {
fn nsid() -> &'static str {
"net.anisota.observatory.layout"
}
fn def_name() -> &'static str {
"main"
}
fn lexicon_doc() -> LexiconDoc<'static> {
lexicon_doc_net_anisota_observatory_layout()
}
fn validate(&self) -> Result<(), ConstraintError> {
if let Some(ref value) = self.description {
#[allow(unused_comparisons)]
if <str>::len(value.as_ref()) > 500usize {
return Err(ConstraintError::MaxLength {
path: ValidationPath::from_field("description"),
max: 500usize,
actual: <str>::len(value.as_ref()),
});
}
}
{
let value = &self.name;
#[allow(unused_comparisons)]
if <str>::len(value.as_ref()) > 80usize {
return Err(ConstraintError::MaxLength {
path: ValidationPath::from_field("name"),
max: 80usize,
actual: <str>::len(value.as_ref()),
});
}
}
Ok(())
}
}
impl<S: BosStr> LexiconSchema for Schedule<S> {
fn nsid() -> &'static str {
"net.anisota.observatory.layout"
}
fn def_name() -> &'static str {
"schedule"
}
fn lexicon_doc() -> LexiconDoc<'static> {
lexicon_doc_net_anisota_observatory_layout()
}
fn validate(&self) -> Result<(), ConstraintError> {
if let Some(ref value) = self.days_of_week {
#[allow(unused_comparisons)]
if value.len() > 7usize {
return Err(ConstraintError::MaxLength {
path: ValidationPath::from_field("days_of_week"),
max: 7usize,
actual: value.len(),
});
}
}
if let Some(ref value) = self.end_time {
#[allow(unused_comparisons)]
if <str>::len(value.as_ref()) > 5usize {
return Err(ConstraintError::MaxLength {
path: ValidationPath::from_field("end_time"),
max: 5usize,
actual: <str>::len(value.as_ref()),
});
}
}
if let Some(ref value) = self.start_time {
#[allow(unused_comparisons)]
if <str>::len(value.as_ref()) > 5usize {
return Err(ConstraintError::MaxLength {
path: ValidationPath::from_field("start_time"),
max: 5usize,
actual: <str>::len(value.as_ref()),
});
}
}
Ok(())
}
}
impl<S: BosStr> LexiconSchema for Source<S> {
fn nsid() -> &'static str {
"net.anisota.observatory.layout"
}
fn def_name() -> &'static str {
"source"
}
fn lexicon_doc() -> LexiconDoc<'static> {
lexicon_doc_net_anisota_observatory_layout()
}
fn validate(&self) -> Result<(), ConstraintError> {
Ok(())
}
}
fn lexicon_doc_net_anisota_observatory_layout() -> 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.observatory.layout"),
defs: {
let mut map = BTreeMap::new();
map.insert(
SmolStr::new_static("createdBy"),
LexUserType::Object(LexObject {
description: Some(CowStr::new_static(
"Attribution for the original crafter of this layout.",
)),
properties: {
#[allow(unused_mut)]
let mut map = BTreeMap::new();
map.insert(
SmolStr::new_static("did"),
LexObjectProperty::String(LexString {
format: Some(LexStringFormat::Did),
..Default::default()
}),
);
map.insert(
SmolStr::new_static("handle"),
LexObjectProperty::String(LexString {
format: Some(LexStringFormat::Handle),
..Default::default()
}),
);
map
},
..Default::default()
}),
);
map.insert(
SmolStr::new_static("layout"),
LexUserType::Object(LexObject {
description: Some(
CowStr::new_static(
"The grid configuration captured by this layout.",
),
),
properties: {
#[allow(unused_mut)]
let mut map = BTreeMap::new();
map.insert(
SmolStr::new_static("buttons"),
LexObjectProperty::Unknown(LexUnknown {
..Default::default()
}),
);
map.insert(
SmolStr::new_static("patternsIndicator"),
LexObjectProperty::Unknown(LexUnknown {
..Default::default()
}),
);
map.insert(
SmolStr::new_static("shuffleLayout"),
LexObjectProperty::Boolean(LexBoolean {
..Default::default()
}),
);
map.insert(
SmolStr::new_static("tileOrder"),
LexObjectProperty::Array(LexArray {
description: Some(
CowStr::new_static(
"Unified rendering order. Entries are 'builtin:<key>' or 'element:<index>' into the record's elements array.",
),
),
items: LexArrayItem::String(LexString {
max_length: Some(64usize),
..Default::default()
}),
..Default::default()
}),
);
map
},
..Default::default()
}),
);
map.insert(
SmolStr::new_static("main"),
LexUserType::Record(LexRecord {
description: Some(
CowStr::new_static(
"A saved Observatory grid layout. Each record is a complete, self-contained snapshot of a layout — built-in button configuration, unified tile order, and embedded element snapshots — so it can be shared by URL and saved ('learned') into another user's PDS without depending on the original author's element records, mirroring the spell architecture. tileOrder entries are 'builtin:<key>' for built-in tiles or 'element:<index>' pointing into the embedded elements array. An optional schedule makes the layout activate automatically during a daily time window.",
),
),
key: Some(CowStr::new_static("any")),
record: LexRecordRecord::Object(LexObject {
required: Some(
vec![
SmolStr::new_static("name"),
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 {
description: Some(
CowStr::new_static("When this layout was first saved"),
),
format: Some(LexStringFormat::Datetime),
..Default::default()
}),
);
map.insert(
SmolStr::new_static("createdBy"),
LexObjectProperty::Ref(LexRef {
r#ref: CowStr::new_static("#createdBy"),
..Default::default()
}),
);
map.insert(
SmolStr::new_static("description"),
LexObjectProperty::String(LexString {
description: Some(
CowStr::new_static(
"Optional description of what this layout is for",
),
),
max_length: Some(500usize),
..Default::default()
}),
);
map.insert(
SmolStr::new_static("elements"),
LexObjectProperty::Array(LexArray {
description: Some(
CowStr::new_static(
"Embedded snapshots of the custom elements this layout uses. Each entry mirrors the shape of a net.anisota.observatory.element record body (type, name, description, plus the type-specific payload: button, note, quote, reminder, divider, spacer, heading, or widget).",
),
),
items: LexArrayItem::Unknown(LexUnknown {
..Default::default()
}),
..Default::default()
}),
);
map.insert(
SmolStr::new_static("layout"),
LexObjectProperty::Ref(LexRef {
r#ref: CowStr::new_static("#layout"),
..Default::default()
}),
);
map.insert(
SmolStr::new_static("name"),
LexObjectProperty::String(LexString {
description: Some(
CowStr::new_static("Display name for this layout"),
),
max_length: Some(80usize),
..Default::default()
}),
);
map.insert(
SmolStr::new_static("schedule"),
LexObjectProperty::Ref(LexRef {
r#ref: CowStr::new_static("#schedule"),
..Default::default()
}),
);
map.insert(
SmolStr::new_static("source"),
LexObjectProperty::Ref(LexRef {
r#ref: CowStr::new_static("#source"),
..Default::default()
}),
);
map.insert(
SmolStr::new_static("updatedAt"),
LexObjectProperty::String(LexString {
description: Some(
CowStr::new_static("When this layout was last modified"),
),
format: Some(LexStringFormat::Datetime),
..Default::default()
}),
);
map
},
..Default::default()
}),
..Default::default()
}),
);
map.insert(
SmolStr::new_static("schedule"),
LexUserType::Object(LexObject {
description: Some(
CowStr::new_static(
"Optional daily activation window. When enabled, the layout takes over the Observatory between startTime and endTime (wrapping past midnight when startTime > endTime), optionally restricted to certain days of the week.",
),
),
properties: {
#[allow(unused_mut)]
let mut map = BTreeMap::new();
map.insert(
SmolStr::new_static("daysOfWeek"),
LexObjectProperty::Array(LexArray {
description: Some(
CowStr::new_static(
"Days the window applies to (0 = Sunday … 6 = Saturday). Empty or absent means every day.",
),
),
items: LexArrayItem::Integer(LexInteger {
..Default::default()
}),
max_length: Some(7usize),
..Default::default()
}),
);
map.insert(
SmolStr::new_static("enabled"),
LexObjectProperty::Boolean(LexBoolean {
..Default::default()
}),
);
map.insert(
SmolStr::new_static("endTime"),
LexObjectProperty::String(LexString {
description: Some(
CowStr::new_static(
"Window end as 'HH:MM' (24-hour, local time)",
),
),
max_length: Some(5usize),
..Default::default()
}),
);
map.insert(
SmolStr::new_static("startTime"),
LexObjectProperty::String(LexString {
description: Some(
CowStr::new_static(
"Window start as 'HH:MM' (24-hour, local time)",
),
),
max_length: Some(5usize),
..Default::default()
}),
);
map
},
..Default::default()
}),
);
map.insert(
SmolStr::new_static("source"),
LexUserType::Object(LexObject {
description: Some(CowStr::new_static(
"Provenance backlink for layouts learned from another user.",
)),
properties: {
#[allow(unused_mut)]
let mut map = BTreeMap::new();
map.insert(
SmolStr::new_static("originalDid"),
LexObjectProperty::String(LexString {
description: Some(CowStr::new_static(
"DID of the user this layout was learned from",
)),
format: Some(LexStringFormat::Did),
..Default::default()
}),
);
map.insert(
SmolStr::new_static("originalUri"),
LexObjectProperty::String(LexString {
description: Some(CowStr::new_static(
"AT URI of the record this layout was learned from",
)),
format: Some(LexStringFormat::AtUri),
..Default::default()
}),
);
map.insert(
SmolStr::new_static("type"),
LexObjectProperty::String(LexString {
..Default::default()
}),
);
map
},
..Default::default()
}),
);
map
},
..Default::default()
}
}
pub mod layout_record_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 Name;
type UpdatedAt;
}
/// 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 UpdatedAt = 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 UpdatedAt = St::UpdatedAt;
}
///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 UpdatedAt = St::UpdatedAt;
}
///State transition - sets the `updated_at` field to Set
pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
impl<St: State> State for SetUpdatedAt<St> {
type CreatedAt = St::CreatedAt;
type Name = St::Name;
type UpdatedAt = Set<members::updated_at>;
}
/// 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 `updated_at` field
pub struct updated_at(());
}
}
/// Builder for constructing an instance of this type.
pub struct LayoutRecordBuilder<St: layout_record_state::State, S: BosStr = DefaultStr> {
_state: PhantomData<fn() -> St>,
_fields: (
Option<Datetime>,
Option<layout::CreatedBy<S>>,
Option<S>,
Option<Vec<Data<S>>>,
Option<layout::Layout<S>>,
Option<S>,
Option<layout::Schedule<S>>,
Option<layout::Source<S>>,
Option<Datetime>,
),
_type: PhantomData<fn() -> S>,
}
impl LayoutRecord<DefaultStr> {
/// Create a new builder for this type, using the default string type (DefaultStr = SmolStr) if needed
pub fn new() -> LayoutRecordBuilder<layout_record_state::Empty, DefaultStr> {
LayoutRecordBuilder::new()
}
}
impl<S: BosStr> LayoutRecord<S> {
/// Create a new builder for this type
pub fn builder() -> LayoutRecordBuilder<layout_record_state::Empty, S> {
LayoutRecordBuilder::builder()
}
}
impl LayoutRecordBuilder<layout_record_state::Empty, DefaultStr> {
/// Create a new builder with all fields unset, using the default string type, if needed
pub fn new() -> Self {
LayoutRecordBuilder {
_state: PhantomData,
_fields: (None, None, None, None, None, None, None, None, None),
_type: PhantomData,
}
}
}
impl<S: BosStr> LayoutRecordBuilder<layout_record_state::Empty, S> {
/// Create a new builder with all fields unset
pub fn builder() -> Self {
LayoutRecordBuilder {
_state: PhantomData,
_fields: (None, None, None, None, None, None, None, None, None),
_type: PhantomData,
}
}
}
impl<St, S: BosStr> LayoutRecordBuilder<St, S>
where
St: layout_record_state::State,
St::CreatedAt: layout_record_state::IsUnset,
{
/// Set the `createdAt` field (required)
pub fn created_at(
mut self,
value: impl Into<Datetime>,
) -> LayoutRecordBuilder<layout_record_state::SetCreatedAt<St>, S> {
self._fields.0 = Option::Some(value.into());
LayoutRecordBuilder {
_state: PhantomData,
_fields: self._fields,
_type: PhantomData,
}
}
}
impl<St: layout_record_state::State, S: BosStr> LayoutRecordBuilder<St, S> {
/// Set the `createdBy` field (optional)
pub fn created_by(mut self, value: impl Into<Option<layout::CreatedBy<S>>>) -> Self {
self._fields.1 = value.into();
self
}
/// Set the `createdBy` field to an Option value (optional)
pub fn maybe_created_by(mut self, value: Option<layout::CreatedBy<S>>) -> Self {
self._fields.1 = value;
self
}
}
impl<St: layout_record_state::State, S: BosStr> LayoutRecordBuilder<St, S> {
/// Set the `description` field (optional)
pub fn description(mut self, value: impl Into<Option<S>>) -> Self {
self._fields.2 = value.into();
self
}
/// Set the `description` field to an Option value (optional)
pub fn maybe_description(mut self, value: Option<S>) -> Self {
self._fields.2 = value;
self
}
}
impl<St: layout_record_state::State, S: BosStr> LayoutRecordBuilder<St, S> {
/// Set the `elements` field (optional)
pub fn elements(mut self, value: impl Into<Option<Vec<Data<S>>>>) -> Self {
self._fields.3 = value.into();
self
}
/// Set the `elements` field to an Option value (optional)
pub fn maybe_elements(mut self, value: Option<Vec<Data<S>>>) -> Self {
self._fields.3 = value;
self
}
}
impl<St: layout_record_state::State, S: BosStr> LayoutRecordBuilder<St, S> {
/// Set the `layout` field (optional)
pub fn layout(mut self, value: impl Into<Option<layout::Layout<S>>>) -> Self {
self._fields.4 = value.into();
self
}
/// Set the `layout` field to an Option value (optional)
pub fn maybe_layout(mut self, value: Option<layout::Layout<S>>) -> Self {
self._fields.4 = value;
self
}
}
impl<St, S: BosStr> LayoutRecordBuilder<St, S>
where
St: layout_record_state::State,
St::Name: layout_record_state::IsUnset,
{
/// Set the `name` field (required)
pub fn name(
mut self,
value: impl Into<S>,
) -> LayoutRecordBuilder<layout_record_state::SetName<St>, S> {
self._fields.5 = Option::Some(value.into());
LayoutRecordBuilder {
_state: PhantomData,
_fields: self._fields,
_type: PhantomData,
}
}
}
impl<St: layout_record_state::State, S: BosStr> LayoutRecordBuilder<St, S> {
/// Set the `schedule` field (optional)
pub fn schedule(mut self, value: impl Into<Option<layout::Schedule<S>>>) -> Self {
self._fields.6 = value.into();
self
}
/// Set the `schedule` field to an Option value (optional)
pub fn maybe_schedule(mut self, value: Option<layout::Schedule<S>>) -> Self {
self._fields.6 = value;
self
}
}
impl<St: layout_record_state::State, S: BosStr> LayoutRecordBuilder<St, S> {
/// Set the `source` field (optional)
pub fn source(mut self, value: impl Into<Option<layout::Source<S>>>) -> Self {
self._fields.7 = value.into();
self
}
/// Set the `source` field to an Option value (optional)
pub fn maybe_source(mut self, value: Option<layout::Source<S>>) -> Self {
self._fields.7 = value;
self
}
}
impl<St, S: BosStr> LayoutRecordBuilder<St, S>
where
St: layout_record_state::State,
St::UpdatedAt: layout_record_state::IsUnset,
{
/// Set the `updatedAt` field (required)
pub fn updated_at(
mut self,
value: impl Into<Datetime>,
) -> LayoutRecordBuilder<layout_record_state::SetUpdatedAt<St>, S> {
self._fields.8 = Option::Some(value.into());
LayoutRecordBuilder {
_state: PhantomData,
_fields: self._fields,
_type: PhantomData,
}
}
}
impl<St, S: BosStr> LayoutRecordBuilder<St, S>
where
St: layout_record_state::State,
St::CreatedAt: layout_record_state::IsSet,
St::Name: layout_record_state::IsSet,
St::UpdatedAt: layout_record_state::IsSet,
{
/// Build the final struct.
pub fn build(self) -> LayoutRecord<S> {
LayoutRecord {
created_at: self._fields.0.unwrap(),
created_by: self._fields.1,
description: self._fields.2,
elements: self._fields.3,
layout: self._fields.4,
name: self._fields.5.unwrap(),
schedule: self._fields.6,
source: self._fields.7,
updated_at: self._fields.8.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>>) -> LayoutRecord<S> {
LayoutRecord {
created_at: self._fields.0.unwrap(),
created_by: self._fields.1,
description: self._fields.2,
elements: self._fields.3,
layout: self._fields.4,
name: self._fields.5.unwrap(),
schedule: self._fields.6,
source: self._fields.7,
updated_at: self._fields.8.unwrap(),
extra_data: Some(extra_data),
}
}
}