jacquard-api 0.12.1

// @generated by jacquard-lexicon. DO NOT EDIT.
//
// Lexicon: net.anisota.lab.inkblot.perception
//
// 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;

use crate::com_atproto::repo::strong_ref::StrongRef;
#[allow(unused_imports)]
use jacquard_lexicon::validation::{ConstraintError, ValidationPath};
use serde::{Deserialize, Serialize};
/// One person's perception of an inkblot — their answer to 'what do you see?'. Points at the inkblot record via a strongRef 'subject'. In the Social Inkblot Test, a viewer's own perception is written before everyone else's perceptions of the same blot are revealed (so the first impression is uncontaminated). Perceptions are aggregated through the Constellation backlink index on '.subject.uri'.

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(
    rename_all = "camelCase",
    rename = "net.anisota.lab.inkblot.perception",
    tag = "$type",
    bound(deserialize = "S: Deserialize<'de> + BosStr")
)]
pub struct Perception<S: BosStr = DefaultStr> {
    ///When the perception was written
    pub created_at: Datetime,
    ///The inkblot record this perception is of
    pub subject: StrongRef<S>,
    ///What the viewer sees in the blot
    pub text: 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 PerceptionGetRecordOutput<S: BosStr = DefaultStr> {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cid: Option<Cid<S>>,
    pub uri: AtUri<S>,
    pub value: Perception<S>,
}

impl<S: BosStr> Perception<S> {
    pub fn uri(uri: S) -> Result<RecordUri<S, PerceptionRecord>, UriError> {
        RecordUri::try_from_uri(AtUri::new(uri)?)
    }
}

/// Marker type for deserializing records from this collection.

#[derive(Debug, Serialize, Deserialize)]
pub struct PerceptionRecord;
impl XrpcResp for PerceptionRecord {
    const NSID: &'static str = "net.anisota.lab.inkblot.perception";
    const ENCODING: &'static str = "application/json";
    type Output<S: BosStr> = PerceptionGetRecordOutput<S>;
    type Err = RecordError;
}

impl<S: BosStr> From<PerceptionGetRecordOutput<S>> for Perception<S> {
    fn from(output: PerceptionGetRecordOutput<S>) -> Self {
        output.value
    }
}

impl<S: BosStr> Collection for Perception<S> {
    const NSID: &'static str = "net.anisota.lab.inkblot.perception";
    type Record = PerceptionRecord;
}

impl Collection for PerceptionRecord {
    const NSID: &'static str = "net.anisota.lab.inkblot.perception";
    type Record = PerceptionRecord;
}

impl<S: BosStr> LexiconSchema for Perception<S> {
    fn nsid() -> &'static str {
        "net.anisota.lab.inkblot.perception"
    }
    fn def_name() -> &'static str {
        "main"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_net_anisota_lab_inkblot_perception()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        {
            let value = &self.text;
            #[allow(unused_comparisons)]
            if <str>::len(value.as_ref()) > 1200usize {
                return Err(ConstraintError::MaxLength {
                    path: ValidationPath::from_field("text"),
                    max: 1200usize,
                    actual: <str>::len(value.as_ref()),
                });
            }
        }
        {
            let value = &self.text;
            {
                let count = UnicodeSegmentation::graphemes(value.as_ref(), true).count();
                if count > 300usize {
                    return Err(ConstraintError::MaxGraphemes {
                        path: ValidationPath::from_field("text"),
                        max: 300usize,
                        actual: count,
                    });
                }
            }
        }
        Ok(())
    }
}

pub mod perception_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 Subject;
        type Text;
    }
    /// Empty state - all required fields are unset
    pub struct Empty(());
    impl sealed::Sealed for Empty {}
    impl State for Empty {
        type CreatedAt = Unset;
        type Subject = Unset;
        type Text = 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 Subject = St::Subject;
        type Text = St::Text;
    }
    ///State transition - sets the `subject` field to Set
    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetSubject<St> {}
    impl<St: State> State for SetSubject<St> {
        type CreatedAt = St::CreatedAt;
        type Subject = Set<members::subject>;
        type Text = St::Text;
    }
    ///State transition - sets the `text` field to Set
    pub struct SetText<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetText<St> {}
    impl<St: State> State for SetText<St> {
        type CreatedAt = St::CreatedAt;
        type Subject = St::Subject;
        type Text = Set<members::text>;
    }
    /// 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 `subject` field
        pub struct subject(());
        ///Marker type for the `text` field
        pub struct text(());
    }
}

/// Builder for constructing an instance of this type.
pub struct PerceptionBuilder<St: perception_state::State, S: BosStr = DefaultStr> {
    _state: PhantomData<fn() -> St>,
    _fields: (Option<Datetime>, Option<StrongRef<S>>, Option<S>),
    _type: PhantomData<fn() -> S>,
}

impl Perception<DefaultStr> {
    /// Create a new builder for this type, using the default string type (DefaultStr = SmolStr) if needed
    pub fn new() -> PerceptionBuilder<perception_state::Empty, DefaultStr> {
        PerceptionBuilder::new()
    }
}

impl<S: BosStr> Perception<S> {
    /// Create a new builder for this type
    pub fn builder() -> PerceptionBuilder<perception_state::Empty, S> {
        PerceptionBuilder::builder()
    }
}

impl PerceptionBuilder<perception_state::Empty, DefaultStr> {
    /// Create a new builder with all fields unset, using the default string type, if needed
    pub fn new() -> Self {
        PerceptionBuilder {
            _state: PhantomData,
            _fields: (None, None, None),
            _type: PhantomData,
        }
    }
}

impl<S: BosStr> PerceptionBuilder<perception_state::Empty, S> {
    /// Create a new builder with all fields unset
    pub fn builder() -> Self {
        PerceptionBuilder {
            _state: PhantomData,
            _fields: (None, None, None),
            _type: PhantomData,
        }
    }
}

impl<St, S: BosStr> PerceptionBuilder<St, S>
where
    St: perception_state::State,
    St::CreatedAt: perception_state::IsUnset,
{
    /// Set the `createdAt` field (required)
    pub fn created_at(
        mut self,
        value: impl Into<Datetime>,
    ) -> PerceptionBuilder<perception_state::SetCreatedAt<St>, S> {
        self._fields.0 = Option::Some(value.into());
        PerceptionBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<St, S: BosStr> PerceptionBuilder<St, S>
where
    St: perception_state::State,
    St::Subject: perception_state::IsUnset,
{
    /// Set the `subject` field (required)
    pub fn subject(
        mut self,
        value: impl Into<StrongRef<S>>,
    ) -> PerceptionBuilder<perception_state::SetSubject<St>, S> {
        self._fields.1 = Option::Some(value.into());
        PerceptionBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<St, S: BosStr> PerceptionBuilder<St, S>
where
    St: perception_state::State,
    St::Text: perception_state::IsUnset,
{
    /// Set the `text` field (required)
    pub fn text(
        mut self,
        value: impl Into<S>,
    ) -> PerceptionBuilder<perception_state::SetText<St>, S> {
        self._fields.2 = Option::Some(value.into());
        PerceptionBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<St, S: BosStr> PerceptionBuilder<St, S>
where
    St: perception_state::State,
    St::CreatedAt: perception_state::IsSet,
    St::Subject: perception_state::IsSet,
    St::Text: perception_state::IsSet,
{
    /// Build the final struct.
    pub fn build(self) -> Perception<S> {
        Perception {
            created_at: self._fields.0.unwrap(),
            subject: self._fields.1.unwrap(),
            text: self._fields.2.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>>) -> Perception<S> {
        Perception {
            created_at: self._fields.0.unwrap(),
            subject: self._fields.1.unwrap(),
            text: self._fields.2.unwrap(),
            extra_data: Some(extra_data),
        }
    }
}

fn lexicon_doc_net_anisota_lab_inkblot_perception() -> 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.inkblot.perception"),
        defs: {
            let mut map = BTreeMap::new();
            map.insert(
                SmolStr::new_static("main"),
                LexUserType::Record(LexRecord {
                    description: Some(
                        CowStr::new_static(
                            "One person's perception of an inkblot — their answer to 'what do you see?'. Points at the inkblot record via a strongRef 'subject'. In the Social Inkblot Test, a viewer's own perception is written before everyone else's perceptions of the same blot are revealed (so the first impression is uncontaminated). Perceptions are aggregated through the Constellation backlink index on '.subject.uri'.",
                        ),
                    ),
                    key: Some(CowStr::new_static("tid")),
                    record: LexRecordRecord::Object(LexObject {
                        required: Some(
                            vec![
                                SmolStr::new_static("subject"), SmolStr::new_static("text"),
                                SmolStr::new_static("createdAt")
                            ],
                        ),
                        properties: {
                            #[allow(unused_mut)]
                            let mut map = BTreeMap::new();
                            map.insert(
                                SmolStr::new_static("createdAt"),
                                LexObjectProperty::String(LexString {
                                    description: Some(
                                        CowStr::new_static("When the perception was written"),
                                    ),
                                    format: Some(LexStringFormat::Datetime),
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("subject"),
                                LexObjectProperty::Ref(LexRef {
                                    r#ref: CowStr::new_static("com.atproto.repo.strongRef"),
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("text"),
                                LexObjectProperty::String(LexString {
                                    description: Some(
                                        CowStr::new_static("What the viewer sees in the blot"),
                                    ),
                                    max_length: Some(1200usize),
                                    max_graphemes: Some(300usize),
                                    ..Default::default()
                                }),
                            );
                            map
                        },
                        ..Default::default()
                    }),
                    ..Default::default()
                }),
            );
            map
        },
        ..Default::default()
    }
}