jacquard-api 0.11.1

// @generated by jacquard-lexicon. DO NOT EDIT.
//
// Lexicon: app.bsky.graph.verification
//
// 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;

#[allow(unused_imports)]
use jacquard_common::deps::codegen::unicode_segmentation::UnicodeSegmentation;
use jacquard_common::types::collection::{Collection, RecordError};
use jacquard_common::types::string::{Did, Handle, AtUri, Cid, Datetime};
use jacquard_common::types::uri::{RecordUri, UriError};
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};
/// Record declaring a verification relationship between two accounts. Verifications are only considered valid by an app if issued by an account the app considers trusted.

#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase", rename = "app.bsky.graph.verification", tag = "$type")]
pub struct Verification<'a> {
    ///Date of when the verification was created.
    pub created_at: Datetime,
    ///Display name of the subject the verification applies to at the moment of verifying, which might not be the same at the time of viewing. The verification is only valid if the current displayName matches the one at the time of verifying.
    #[serde(borrow)]
    pub display_name: CowStr<'a>,
    ///Handle of the subject the verification applies to at the moment of verifying, which might not be the same at the time of viewing. The verification is only valid if the current handle matches the one at the time of verifying.
    #[serde(borrow)]
    pub handle: Handle<'a>,
    ///DID of the subject the verification applies to.
    #[serde(borrow)]
    pub subject: Did<'a>,
}

/// 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 VerificationGetRecordOutput<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub cid: Option<Cid<'a>>,
    #[serde(borrow)]
    pub uri: AtUri<'a>,
    #[serde(borrow)]
    pub value: Verification<'a>,
}

impl<'a> Verification<'a> {
    pub fn uri(
        uri: impl Into<CowStr<'a>>,
    ) -> Result<RecordUri<'a, VerificationRecord>, UriError> {
        RecordUri::try_from_uri(AtUri::new_cow(uri.into())?)
    }
}

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

#[derive(Debug, Serialize, Deserialize)]
pub struct VerificationRecord;
impl XrpcResp for VerificationRecord {
    const NSID: &'static str = "app.bsky.graph.verification";
    const ENCODING: &'static str = "application/json";
    type Output<'de> = VerificationGetRecordOutput<'de>;
    type Err<'de> = RecordError<'de>;
}

impl From<VerificationGetRecordOutput<'_>> for Verification<'_> {
    fn from(output: VerificationGetRecordOutput<'_>) -> Self {
        use jacquard_common::IntoStatic;
        output.value.into_static()
    }
}

impl Collection for Verification<'_> {
    const NSID: &'static str = "app.bsky.graph.verification";
    type Record = VerificationRecord;
}

impl Collection for VerificationRecord {
    const NSID: &'static str = "app.bsky.graph.verification";
    type Record = VerificationRecord;
}

impl<'a> LexiconSchema for Verification<'a> {
    fn nsid() -> &'static str {
        "app.bsky.graph.verification"
    }
    fn def_name() -> &'static str {
        "main"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_app_bsky_graph_verification()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

pub mod verification_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 Subject;
        type CreatedAt;
        type DisplayName;
        type Handle;
    }
    /// Empty state - all required fields are unset
    pub struct Empty(());
    impl sealed::Sealed for Empty {}
    impl State for Empty {
        type Subject = Unset;
        type CreatedAt = Unset;
        type DisplayName = Unset;
        type Handle = Unset;
    }
    ///State transition - sets the `subject` field to Set
    pub struct SetSubject<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetSubject<S> {}
    impl<S: State> State for SetSubject<S> {
        type Subject = Set<members::subject>;
        type CreatedAt = S::CreatedAt;
        type DisplayName = S::DisplayName;
        type Handle = S::Handle;
    }
    ///State transition - sets the `created_at` field to Set
    pub struct SetCreatedAt<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetCreatedAt<S> {}
    impl<S: State> State for SetCreatedAt<S> {
        type Subject = S::Subject;
        type CreatedAt = Set<members::created_at>;
        type DisplayName = S::DisplayName;
        type Handle = S::Handle;
    }
    ///State transition - sets the `display_name` field to Set
    pub struct SetDisplayName<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetDisplayName<S> {}
    impl<S: State> State for SetDisplayName<S> {
        type Subject = S::Subject;
        type CreatedAt = S::CreatedAt;
        type DisplayName = Set<members::display_name>;
        type Handle = S::Handle;
    }
    ///State transition - sets the `handle` field to Set
    pub struct SetHandle<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetHandle<S> {}
    impl<S: State> State for SetHandle<S> {
        type Subject = S::Subject;
        type CreatedAt = S::CreatedAt;
        type DisplayName = S::DisplayName;
        type Handle = Set<members::handle>;
    }
    /// Marker types for field names
    #[allow(non_camel_case_types)]
    pub mod members {
        ///Marker type for the `subject` field
        pub struct subject(());
        ///Marker type for the `created_at` field
        pub struct created_at(());
        ///Marker type for the `display_name` field
        pub struct display_name(());
        ///Marker type for the `handle` field
        pub struct handle(());
    }
}

/// Builder for constructing an instance of this type
pub struct VerificationBuilder<'a, S: verification_state::State> {
    _state: PhantomData<fn() -> S>,
    _fields: (Option<Datetime>, Option<CowStr<'a>>, Option<Handle<'a>>, Option<Did<'a>>),
    _lifetime: PhantomData<&'a ()>,
}

impl<'a> Verification<'a> {
    /// Create a new builder for this type
    pub fn new() -> VerificationBuilder<'a, verification_state::Empty> {
        VerificationBuilder::new()
    }
}

impl<'a> VerificationBuilder<'a, verification_state::Empty> {
    /// Create a new builder with all fields unset
    pub fn new() -> Self {
        VerificationBuilder {
            _state: PhantomData,
            _fields: (None, None, None, None),
            _lifetime: PhantomData,
        }
    }
}

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

impl<'a, S> VerificationBuilder<'a, S>
where
    S: verification_state::State,
    S::DisplayName: verification_state::IsUnset,
{
    /// Set the `displayName` field (required)
    pub fn display_name(
        mut self,
        value: impl Into<CowStr<'a>>,
    ) -> VerificationBuilder<'a, verification_state::SetDisplayName<S>> {
        self._fields.1 = Option::Some(value.into());
        VerificationBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S> VerificationBuilder<'a, S>
where
    S: verification_state::State,
    S::Handle: verification_state::IsUnset,
{
    /// Set the `handle` field (required)
    pub fn handle(
        mut self,
        value: impl Into<Handle<'a>>,
    ) -> VerificationBuilder<'a, verification_state::SetHandle<S>> {
        self._fields.2 = Option::Some(value.into());
        VerificationBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S> VerificationBuilder<'a, S>
where
    S: verification_state::State,
    S::Subject: verification_state::IsUnset,
{
    /// Set the `subject` field (required)
    pub fn subject(
        mut self,
        value: impl Into<Did<'a>>,
    ) -> VerificationBuilder<'a, verification_state::SetSubject<S>> {
        self._fields.3 = Option::Some(value.into());
        VerificationBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S> VerificationBuilder<'a, S>
where
    S: verification_state::State,
    S::Subject: verification_state::IsSet,
    S::CreatedAt: verification_state::IsSet,
    S::DisplayName: verification_state::IsSet,
    S::Handle: verification_state::IsSet,
{
    /// Build the final struct
    pub fn build(self) -> Verification<'a> {
        Verification {
            created_at: self._fields.0.unwrap(),
            display_name: self._fields.1.unwrap(),
            handle: self._fields.2.unwrap(),
            subject: self._fields.3.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>,
        >,
    ) -> Verification<'a> {
        Verification {
            created_at: self._fields.0.unwrap(),
            display_name: self._fields.1.unwrap(),
            handle: self._fields.2.unwrap(),
            subject: self._fields.3.unwrap(),
            extra_data: Some(extra_data),
        }
    }
}

fn lexicon_doc_app_bsky_graph_verification() -> 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("app.bsky.graph.verification"),
        defs: {
            let mut map = BTreeMap::new();
            map.insert(
                SmolStr::new_static("main"),
                LexUserType::Record(LexRecord {
                    description: Some(
                        CowStr::new_static(
                            "Record declaring a verification relationship between two accounts. Verifications are only considered valid by an app if issued by an account the app considers trusted.",
                        ),
                    ),
                    key: Some(CowStr::new_static("tid")),
                    record: LexRecordRecord::Object(LexObject {
                        required: Some(
                            vec![
                                SmolStr::new_static("subject"),
                                SmolStr::new_static("handle"),
                                SmolStr::new_static("displayName"),
                                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(
                                            "Date of when the verification was created.",
                                        ),
                                    ),
                                    format: Some(LexStringFormat::Datetime),
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("displayName"),
                                LexObjectProperty::String(LexString {
                                    description: Some(
                                        CowStr::new_static(
                                            "Display name of the subject the verification applies to at the moment of verifying, which might not be the same at the time of viewing. The verification is only valid if the current displayName matches the one at the time of verifying.",
                                        ),
                                    ),
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("handle"),
                                LexObjectProperty::String(LexString {
                                    description: Some(
                                        CowStr::new_static(
                                            "Handle of the subject the verification applies to at the moment of verifying, which might not be the same at the time of viewing. The verification is only valid if the current handle matches the one at the time of verifying.",
                                        ),
                                    ),
                                    format: Some(LexStringFormat::Handle),
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("subject"),
                                LexObjectProperty::String(LexString {
                                    description: Some(
                                        CowStr::new_static(
                                            "DID of the subject the verification applies to.",
                                        ),
                                    ),
                                    format: Some(LexStringFormat::Did),
                                    ..Default::default()
                                }),
                            );
                            map
                        },
                        ..Default::default()
                    }),
                    ..Default::default()
                }),
            );
            map
        },
        ..Default::default()
    }
}