jacquard-api 0.12.0-beta.2

// @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::{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;

#[allow(unused_imports)]
use jacquard_lexicon::validation::{ConstraintError, ValidationPath};
use serde::{Deserialize, Serialize};
/// 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.

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(
    rename_all = "camelCase",
    rename = "app.bsky.graph.verification",
    tag = "$type",
    bound(deserialize = "S: Deserialize<'de> + BosStr")
)]
pub struct Verification<S: BosStr = DefaultStr> {
    ///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.
    pub display_name: S,
    ///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.
    pub handle: Handle<S>,
    ///DID of the subject the verification applies to.
    pub subject: Did<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 VerificationGetRecordOutput<S: BosStr = DefaultStr> {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cid: Option<Cid<S>>,
    pub uri: AtUri<S>,
    pub value: Verification<S>,
}

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

/// 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<S: BosStr> = VerificationGetRecordOutput<S>;
    type Err = RecordError;
}

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

impl<S: BosStr> Collection for Verification<S> {
    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<S: BosStr> LexiconSchema for Verification<S> {
    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::{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 Subject;
        type Handle;
        type DisplayName;
        type CreatedAt;
    }
    /// Empty state - all required fields are unset
    pub struct Empty(());
    impl sealed::Sealed for Empty {}
    impl State for Empty {
        type Subject = Unset;
        type Handle = Unset;
        type DisplayName = Unset;
        type CreatedAt = Unset;
    }
    ///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 Subject = Set<members::subject>;
        type Handle = St::Handle;
        type DisplayName = St::DisplayName;
        type CreatedAt = St::CreatedAt;
    }
    ///State transition - sets the `handle` field to Set
    pub struct SetHandle<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetHandle<St> {}
    impl<St: State> State for SetHandle<St> {
        type Subject = St::Subject;
        type Handle = Set<members::handle>;
        type DisplayName = St::DisplayName;
        type CreatedAt = St::CreatedAt;
    }
    ///State transition - sets the `display_name` field to Set
    pub struct SetDisplayName<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetDisplayName<St> {}
    impl<St: State> State for SetDisplayName<St> {
        type Subject = St::Subject;
        type Handle = St::Handle;
        type DisplayName = Set<members::display_name>;
        type CreatedAt = St::CreatedAt;
    }
    ///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 Subject = St::Subject;
        type Handle = St::Handle;
        type DisplayName = St::DisplayName;
        type CreatedAt = Set<members::created_at>;
    }
    /// 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 `handle` field
        pub struct handle(());
        ///Marker type for the `display_name` field
        pub struct display_name(());
        ///Marker type for the `created_at` field
        pub struct created_at(());
    }
}

/// Builder for constructing an instance of this type.
pub struct VerificationBuilder<S: BosStr, St: verification_state::State> {
    _state: PhantomData<fn() -> St>,
    _fields: (
        Option<Datetime>,
        Option<S>,
        Option<Handle<S>>,
        Option<Did<S>>,
    ),
    _type: PhantomData<fn() -> S>,
}

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

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

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

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

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

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

impl<S: BosStr, St> VerificationBuilder<S, St>
where
    St: verification_state::State,
    St::Subject: verification_state::IsSet,
    St::Handle: verification_state::IsSet,
    St::DisplayName: verification_state::IsSet,
    St::CreatedAt: verification_state::IsSet,
{
    /// Build the final struct.
    pub fn build(self) -> Verification<S> {
        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<SmolStr, Data<S>>) -> Verification<S> {
        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> {
    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("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()
    }
}