pub mod collection;
pub mod feed;
pub mod graph;
pub mod library;
pub mod profile;
#[jacquard_derive::lexicon]
#[derive(
serde::Serialize,
serde::Deserialize,
Debug,
Clone,
PartialEq,
Eq,
jacquard_derive::IntoStatic
)]
#[serde(rename_all = "camelCase")]
pub struct ActivitySettings<'a> {
#[serde(default = "_default_activity_settings_retention_days")]
pub retention_days: i64,
#[serde(borrow)]
pub share_activity: ActivitySettingsShareActivity<'a>,
pub share_new_items: bool,
}
fn _default_activity_settings_retention_days() -> i64 {
90i64
}
pub mod activity_settings_state {
pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
#[allow(unused)]
use ::core::marker::PhantomData;
mod sealed {
pub trait Sealed {}
}
pub trait State: sealed::Sealed {
type ShareNewItems;
type RetentionDays;
type ShareActivity;
}
pub struct Empty(());
impl sealed::Sealed for Empty {}
impl State for Empty {
type ShareNewItems = Unset;
type RetentionDays = Unset;
type ShareActivity = Unset;
}
pub struct SetShareNewItems<S: State = Empty>(PhantomData<fn() -> S>);
impl<S: State> sealed::Sealed for SetShareNewItems<S> {}
impl<S: State> State for SetShareNewItems<S> {
type ShareNewItems = Set<members::share_new_items>;
type RetentionDays = S::RetentionDays;
type ShareActivity = S::ShareActivity;
}
pub struct SetRetentionDays<S: State = Empty>(PhantomData<fn() -> S>);
impl<S: State> sealed::Sealed for SetRetentionDays<S> {}
impl<S: State> State for SetRetentionDays<S> {
type ShareNewItems = S::ShareNewItems;
type RetentionDays = Set<members::retention_days>;
type ShareActivity = S::ShareActivity;
}
pub struct SetShareActivity<S: State = Empty>(PhantomData<fn() -> S>);
impl<S: State> sealed::Sealed for SetShareActivity<S> {}
impl<S: State> State for SetShareActivity<S> {
type ShareNewItems = S::ShareNewItems;
type RetentionDays = S::RetentionDays;
type ShareActivity = Set<members::share_activity>;
}
#[allow(non_camel_case_types)]
pub mod members {
pub struct share_new_items(());
pub struct retention_days(());
pub struct share_activity(());
}
}
pub struct ActivitySettingsBuilder<'a, S: activity_settings_state::State> {
_phantom_state: ::core::marker::PhantomData<fn() -> S>,
__unsafe_private_named: (
::core::option::Option<i64>,
::core::option::Option<ActivitySettingsShareActivity<'a>>,
::core::option::Option<bool>,
),
_phantom: ::core::marker::PhantomData<&'a ()>,
}
impl<'a> ActivitySettings<'a> {
pub fn new() -> ActivitySettingsBuilder<'a, activity_settings_state::Empty> {
ActivitySettingsBuilder::new()
}
}
impl<'a> ActivitySettingsBuilder<'a, activity_settings_state::Empty> {
pub fn new() -> Self {
ActivitySettingsBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: (None, None, None),
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> ActivitySettingsBuilder<'a, S>
where
S: activity_settings_state::State,
S::RetentionDays: activity_settings_state::IsUnset,
{
pub fn retention_days(
mut self,
value: impl Into<i64>,
) -> ActivitySettingsBuilder<'a, activity_settings_state::SetRetentionDays<S>> {
self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
ActivitySettingsBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> ActivitySettingsBuilder<'a, S>
where
S: activity_settings_state::State,
S::ShareActivity: activity_settings_state::IsUnset,
{
pub fn share_activity(
mut self,
value: impl Into<ActivitySettingsShareActivity<'a>>,
) -> ActivitySettingsBuilder<'a, activity_settings_state::SetShareActivity<S>> {
self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
ActivitySettingsBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> ActivitySettingsBuilder<'a, S>
where
S: activity_settings_state::State,
S::ShareNewItems: activity_settings_state::IsUnset,
{
pub fn share_new_items(
mut self,
value: impl Into<bool>,
) -> ActivitySettingsBuilder<'a, activity_settings_state::SetShareNewItems<S>> {
self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into());
ActivitySettingsBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> ActivitySettingsBuilder<'a, S>
where
S: activity_settings_state::State,
S::ShareNewItems: activity_settings_state::IsSet,
S::RetentionDays: activity_settings_state::IsSet,
S::ShareActivity: activity_settings_state::IsSet,
{
pub fn build(self) -> ActivitySettings<'a> {
ActivitySettings {
retention_days: self.__unsafe_private_named.0.unwrap(),
share_activity: self.__unsafe_private_named.1.unwrap(),
share_new_items: self.__unsafe_private_named.2.unwrap(),
extra_data: Default::default(),
}
}
pub fn build_with_data(
self,
extra_data: std::collections::BTreeMap<
jacquard_common::deps::smol_str::SmolStr,
jacquard_common::types::value::Data<'a>,
>,
) -> ActivitySettings<'a> {
ActivitySettings {
retention_days: self.__unsafe_private_named.0.unwrap(),
share_activity: self.__unsafe_private_named.1.unwrap(),
share_new_items: self.__unsafe_private_named.2.unwrap(),
extra_data: Some(extra_data),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum ActivitySettingsShareActivity<'a> {
All,
Followers,
None,
Other(jacquard_common::CowStr<'a>),
}
impl<'a> ActivitySettingsShareActivity<'a> {
pub fn as_str(&self) -> &str {
match self {
Self::All => "all",
Self::Followers => "followers",
Self::None => "none",
Self::Other(s) => s.as_ref(),
}
}
}
impl<'a> From<&'a str> for ActivitySettingsShareActivity<'a> {
fn from(s: &'a str) -> Self {
match s {
"all" => Self::All,
"followers" => Self::Followers,
"none" => Self::None,
_ => Self::Other(jacquard_common::CowStr::from(s)),
}
}
}
impl<'a> From<String> for ActivitySettingsShareActivity<'a> {
fn from(s: String) -> Self {
match s.as_str() {
"all" => Self::All,
"followers" => Self::Followers,
"none" => Self::None,
_ => Self::Other(jacquard_common::CowStr::from(s)),
}
}
}
impl<'a> core::fmt::Display for ActivitySettingsShareActivity<'a> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "{}", self.as_str())
}
}
impl<'a> AsRef<str> for ActivitySettingsShareActivity<'a> {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl<'a> serde::Serialize for ActivitySettingsShareActivity<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serializer.serialize_str(self.as_str())
}
}
impl<'de, 'a> serde::Deserialize<'de> for ActivitySettingsShareActivity<'a>
where
'de: 'a,
{
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let s = <&'de str>::deserialize(deserializer)?;
Ok(Self::from(s))
}
}
impl<'a> Default for ActivitySettingsShareActivity<'a> {
fn default() -> Self {
Self::Other(Default::default())
}
}
impl jacquard_common::IntoStatic for ActivitySettingsShareActivity<'_> {
type Output = ActivitySettingsShareActivity<'static>;
fn into_static(self) -> Self::Output {
match self {
ActivitySettingsShareActivity::All => ActivitySettingsShareActivity::All,
ActivitySettingsShareActivity::Followers => {
ActivitySettingsShareActivity::Followers
}
ActivitySettingsShareActivity::None => ActivitySettingsShareActivity::None,
ActivitySettingsShareActivity::Other(v) => {
ActivitySettingsShareActivity::Other(v.into_static())
}
}
}
}
fn lexicon_doc_social_showcase_defs() -> ::jacquard_lexicon::lexicon::LexiconDoc<
'static,
> {
::jacquard_lexicon::lexicon::LexiconDoc {
lexicon: ::jacquard_lexicon::lexicon::Lexicon::Lexicon1,
id: ::jacquard_common::CowStr::new_static("social.showcase.defs"),
revision: None,
description: None,
defs: {
let mut map = ::alloc::collections::BTreeMap::new();
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"activitySettings",
),
::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
description: Some(
::jacquard_common::CowStr::new_static(
"Activity sharing preferences",
),
),
required: Some(
vec![
::jacquard_common::deps::smol_str::SmolStr::new_static("shareNewItems"),
::jacquard_common::deps::smol_str::SmolStr::new_static("shareActivity"),
::jacquard_common::deps::smol_str::SmolStr::new_static("retentionDays")
],
),
nullable: None,
properties: {
#[allow(unused_mut)]
let mut map = ::alloc::collections::BTreeMap::new();
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"retentionDays",
),
::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger {
description: None,
default: None,
minimum: None,
maximum: None,
r#enum: None,
r#const: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"shareActivity",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: Some(
::jacquard_common::CowStr::new_static(
"Who sees your activity feed",
),
),
format: None,
default: None,
min_length: None,
max_length: Some(10usize),
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"shareNewItems",
),
::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
description: None,
default: None,
r#const: None,
}),
);
map
},
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static("aspectRatio"),
::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
description: Some(
::jacquard_common::CowStr::new_static("Image aspect ratio"),
),
required: None,
nullable: None,
properties: {
#[allow(unused_mut)]
let mut map = ::alloc::collections::BTreeMap::new();
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"height",
),
::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger {
description: None,
default: None,
minimum: Some(1i64),
maximum: None,
r#enum: None,
r#const: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"width",
),
::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger {
description: None,
default: None,
minimum: Some(1i64),
maximum: None,
r#enum: None,
r#const: None,
}),
);
map
},
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static("collectionItem"),
::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
description: Some(
::jacquard_common::CowStr::new_static(
"Reference to an item in a collection",
),
),
required: Some(
vec![
::jacquard_common::deps::smol_str::SmolStr::new_static("uri"),
::jacquard_common::deps::smol_str::SmolStr::new_static("addedAt"),
::jacquard_common::deps::smol_str::SmolStr::new_static("order")
],
),
nullable: None,
properties: {
#[allow(unused_mut)]
let mut map = ::alloc::collections::BTreeMap::new();
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"addedAt",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: None,
format: Some(
::jacquard_lexicon::lexicon::LexStringFormat::Datetime,
),
default: None,
min_length: None,
max_length: None,
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"order",
),
::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger {
description: None,
default: None,
minimum: None,
maximum: None,
r#enum: None,
r#const: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"uri",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: Some(
::jacquard_common::CowStr::new_static(
"AT-URI reference to item (always shows latest version)",
),
),
format: None,
default: None,
min_length: None,
max_length: Some(8192usize),
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map
},
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static("collectionView"),
::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
description: Some(
::jacquard_common::CowStr::new_static(
"View of a collection with items",
),
),
required: Some(
vec![
::jacquard_common::deps::smol_str::SmolStr::new_static("uri"),
::jacquard_common::deps::smol_str::SmolStr::new_static("cid"),
::jacquard_common::deps::smol_str::SmolStr::new_static("name"),
::jacquard_common::deps::smol_str::SmolStr::new_static("tags"),
::jacquard_common::deps::smol_str::SmolStr::new_static("type"),
::jacquard_common::deps::smol_str::SmolStr::new_static("visibility"),
::jacquard_common::deps::smol_str::SmolStr::new_static("author"),
::jacquard_common::deps::smol_str::SmolStr::new_static("createdAt")
],
),
nullable: None,
properties: {
#[allow(unused_mut)]
let mut map = ::alloc::collections::BTreeMap::new();
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"author",
),
::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
description: None,
r#ref: ::jacquard_common::CowStr::new_static("#profileView"),
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"cid",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: None,
format: Some(
::jacquard_lexicon::lexicon::LexStringFormat::Cid,
),
default: None,
min_length: None,
max_length: None,
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"coverImage",
),
::jacquard_lexicon::lexicon::LexObjectProperty::Blob(::jacquard_lexicon::lexicon::LexBlob {
description: None,
accept: None,
max_size: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"createdAt",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: None,
format: Some(
::jacquard_lexicon::lexicon::LexStringFormat::Datetime,
),
default: None,
min_length: None,
max_length: None,
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"description",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: None,
format: None,
default: None,
min_length: None,
max_length: Some(1000usize),
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"itemCount",
),
::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger {
description: None,
default: None,
minimum: None,
maximum: None,
r#enum: None,
r#const: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"items",
),
::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
description: None,
items: ::jacquard_lexicon::lexicon::LexArrayItem::Ref(::jacquard_lexicon::lexicon::LexRef {
description: None,
r#ref: ::jacquard_common::CowStr::new_static("#itemView"),
}),
min_length: None,
max_length: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"name",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: None,
format: None,
default: None,
min_length: None,
max_length: Some(200usize),
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"tags",
),
::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
description: None,
items: ::jacquard_lexicon::lexicon::LexArrayItem::String(::jacquard_lexicon::lexicon::LexString {
description: None,
format: None,
default: None,
min_length: None,
max_length: Some(64usize),
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
min_length: None,
max_length: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"type",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: None,
format: None,
default: None,
min_length: None,
max_length: Some(20usize),
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"updatedAt",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: None,
format: Some(
::jacquard_lexicon::lexicon::LexStringFormat::Datetime,
),
default: None,
min_length: None,
max_length: None,
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"uri",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: None,
format: Some(
::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
),
default: None,
min_length: None,
max_length: None,
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"visibility",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: None,
format: None,
default: None,
min_length: None,
max_length: Some(10usize),
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map
},
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"displaySettings",
),
::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
description: Some(
::jacquard_common::CowStr::new_static("Display preferences"),
),
required: None,
nullable: None,
properties: {
#[allow(unused_mut)]
let mut map = ::alloc::collections::BTreeMap::new();
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"gridLayout",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: None,
format: None,
default: None,
min_length: None,
max_length: Some(10usize),
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"theme",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: None,
format: None,
default: None,
min_length: None,
max_length: Some(10usize),
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map
},
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static("itemImage"),
::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
description: Some(
::jacquard_common::CowStr::new_static(
"Image embedded in an item",
),
),
required: Some(
vec![
::jacquard_common::deps::smol_str::SmolStr::new_static("blob")
],
),
nullable: None,
properties: {
#[allow(unused_mut)]
let mut map = ::alloc::collections::BTreeMap::new();
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"alt",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: Some(
::jacquard_common::CowStr::new_static(
"Alt text for accessibility",
),
),
format: None,
default: None,
min_length: None,
max_length: Some(300usize),
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"aspectRatio",
),
::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
description: None,
r#ref: ::jacquard_common::CowStr::new_static("#aspectRatio"),
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"blob",
),
::jacquard_lexicon::lexicon::LexObjectProperty::Blob(::jacquard_lexicon::lexicon::LexBlob {
description: None,
accept: None,
max_size: None,
}),
);
map
},
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static("itemView"),
::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
description: Some(
::jacquard_common::CowStr::new_static(
"View of an item with metadata",
),
),
required: Some(
vec![
::jacquard_common::deps::smol_str::SmolStr::new_static("uri"),
::jacquard_common::deps::smol_str::SmolStr::new_static("cid"),
::jacquard_common::deps::smol_str::SmolStr::new_static("title"),
::jacquard_common::deps::smol_str::SmolStr::new_static("tags"),
::jacquard_common::deps::smol_str::SmolStr::new_static("images"),
::jacquard_common::deps::smol_str::SmolStr::new_static("visibility"),
::jacquard_common::deps::smol_str::SmolStr::new_static("author"),
::jacquard_common::deps::smol_str::SmolStr::new_static("createdAt")
],
),
nullable: None,
properties: {
#[allow(unused_mut)]
let mut map = ::alloc::collections::BTreeMap::new();
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"author",
),
::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
description: None,
r#ref: ::jacquard_common::CowStr::new_static("#profileView"),
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"category",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: None,
format: None,
default: None,
min_length: None,
max_length: Some(100usize),
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"cid",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: None,
format: Some(
::jacquard_lexicon::lexicon::LexStringFormat::Cid,
),
default: None,
min_length: None,
max_length: None,
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"createdAt",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: None,
format: Some(
::jacquard_lexicon::lexicon::LexStringFormat::Datetime,
),
default: None,
min_length: None,
max_length: None,
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"description",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: None,
format: None,
default: None,
min_length: None,
max_length: Some(3000usize),
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"externalLink",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: None,
format: Some(
::jacquard_lexicon::lexicon::LexStringFormat::Uri,
),
default: None,
min_length: None,
max_length: Some(2048usize),
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"images",
),
::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
description: None,
items: ::jacquard_lexicon::lexicon::LexArrayItem::Ref(::jacquard_lexicon::lexicon::LexRef {
description: None,
r#ref: ::jacquard_common::CowStr::new_static("#itemImage"),
}),
min_length: None,
max_length: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"metadata",
),
::jacquard_lexicon::lexicon::LexObjectProperty::Unknown(::jacquard_lexicon::lexicon::LexUnknown {
description: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"reactionCount",
),
::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger {
description: None,
default: None,
minimum: None,
maximum: None,
r#enum: None,
r#const: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"tags",
),
::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
description: None,
items: ::jacquard_lexicon::lexicon::LexArrayItem::String(::jacquard_lexicon::lexicon::LexString {
description: None,
format: None,
default: None,
min_length: None,
max_length: Some(64usize),
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
min_length: None,
max_length: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"title",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: None,
format: None,
default: None,
min_length: None,
max_length: Some(300usize),
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"updatedAt",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: None,
format: Some(
::jacquard_lexicon::lexicon::LexStringFormat::Datetime,
),
default: None,
min_length: None,
max_length: None,
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"uri",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: None,
format: Some(
::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
),
default: None,
min_length: None,
max_length: None,
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"visibility",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: None,
format: None,
default: None,
min_length: None,
max_length: Some(10usize),
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map
},
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"notificationSettings",
),
::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
description: Some(
::jacquard_common::CowStr::new_static("Notification preferences"),
),
required: Some(
vec![
::jacquard_common::deps::smol_str::SmolStr::new_static("reactions"),
::jacquard_common::deps::smol_str::SmolStr::new_static("follows"),
::jacquard_common::deps::smol_str::SmolStr::new_static("comments")
],
),
nullable: None,
properties: {
#[allow(unused_mut)]
let mut map = ::alloc::collections::BTreeMap::new();
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"comments",
),
::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
description: None,
default: None,
r#const: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"follows",
),
::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
description: None,
default: None,
r#const: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"reactions",
),
::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
description: None,
default: None,
r#const: None,
}),
);
map
},
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"privacySettings",
),
::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
description: Some(
::jacquard_common::CowStr::new_static("Privacy preferences"),
),
required: Some(
vec![
::jacquard_common::deps::smol_str::SmolStr::new_static("allowReactions"),
::jacquard_common::deps::smol_str::SmolStr::new_static("allowComments"),
::jacquard_common::deps::smol_str::SmolStr::new_static("indexable")
],
),
nullable: None,
properties: {
#[allow(unused_mut)]
let mut map = ::alloc::collections::BTreeMap::new();
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"allowComments",
),
::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
description: None,
default: None,
r#const: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"allowReactions",
),
::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
description: None,
default: None,
r#const: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"indexable",
),
::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
description: None,
default: None,
r#const: None,
}),
);
map
},
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static("profileView"),
::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
description: Some(
::jacquard_common::CowStr::new_static("View of a user profile"),
),
required: Some(
vec![
::jacquard_common::deps::smol_str::SmolStr::new_static("did"),
::jacquard_common::deps::smol_str::SmolStr::new_static("handle")
],
),
nullable: None,
properties: {
#[allow(unused_mut)]
let mut map = ::alloc::collections::BTreeMap::new();
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"avatar",
),
::jacquard_lexicon::lexicon::LexObjectProperty::Blob(::jacquard_lexicon::lexicon::LexBlob {
description: None,
accept: None,
max_size: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"banner",
),
::jacquard_lexicon::lexicon::LexObjectProperty::Blob(::jacquard_lexicon::lexicon::LexBlob {
description: None,
accept: None,
max_size: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"did",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: None,
format: None,
default: None,
min_length: None,
max_length: Some(2048usize),
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"displayName",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: None,
format: None,
default: None,
min_length: None,
max_length: Some(64usize),
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"handle",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: None,
format: None,
default: None,
min_length: None,
max_length: Some(253usize),
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"tags",
),
::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
description: None,
items: ::jacquard_lexicon::lexicon::LexArrayItem::String(::jacquard_lexicon::lexicon::LexString {
description: None,
format: None,
default: None,
min_length: None,
max_length: Some(64usize),
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
min_length: None,
max_length: None,
}),
);
map
},
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"reactionSubject",
),
::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
description: Some(
::jacquard_common::CowStr::new_static("Subject of a reaction"),
),
required: Some(
vec![
::jacquard_common::deps::smol_str::SmolStr::new_static("uri"),
::jacquard_common::deps::smol_str::SmolStr::new_static("cid")
],
),
nullable: None,
properties: {
#[allow(unused_mut)]
let mut map = ::alloc::collections::BTreeMap::new();
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"cid",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: None,
format: Some(
::jacquard_lexicon::lexicon::LexStringFormat::Cid,
),
default: None,
min_length: None,
max_length: None,
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"uri",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: None,
format: Some(
::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
),
default: None,
min_length: None,
max_length: None,
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map
},
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static("reactionView"),
::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
description: Some(
::jacquard_common::CowStr::new_static(
"View of a reaction to content",
),
),
required: Some(
vec![
::jacquard_common::deps::smol_str::SmolStr::new_static("uri"),
::jacquard_common::deps::smol_str::SmolStr::new_static("actor"),
::jacquard_common::deps::smol_str::SmolStr::new_static("subject"),
::jacquard_common::deps::smol_str::SmolStr::new_static("type"),
::jacquard_common::deps::smol_str::SmolStr::new_static("createdAt")
],
),
nullable: None,
properties: {
#[allow(unused_mut)]
let mut map = ::alloc::collections::BTreeMap::new();
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"actor",
),
::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
description: None,
r#ref: ::jacquard_common::CowStr::new_static("#profileView"),
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"createdAt",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: None,
format: Some(
::jacquard_lexicon::lexicon::LexStringFormat::Datetime,
),
default: None,
min_length: None,
max_length: None,
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"subject",
),
::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
description: None,
r#ref: ::jacquard_common::CowStr::new_static(
"#reactionSubject",
),
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"type",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: Some(
::jacquard_common::CowStr::new_static("Emoji shortcode"),
),
format: None,
default: None,
min_length: None,
max_length: Some(100usize),
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"uri",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: None,
format: Some(
::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
),
default: None,
min_length: None,
max_length: None,
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map
},
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static("showcaseItem"),
::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
description: Some(
::jacquard_common::CowStr::new_static(
"A reference to an item featured in a user's showcase (hydrated at read time)",
),
),
required: Some(
vec![
::jacquard_common::deps::smol_str::SmolStr::new_static("uri"),
::jacquard_common::deps::smol_str::SmolStr::new_static("addedAt"),
::jacquard_common::deps::smol_str::SmolStr::new_static("order")
],
),
nullable: None,
properties: {
#[allow(unused_mut)]
let mut map = ::alloc::collections::BTreeMap::new();
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"addedAt",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: None,
format: Some(
::jacquard_lexicon::lexicon::LexStringFormat::Datetime,
),
default: None,
min_length: None,
max_length: None,
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"order",
),
::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger {
description: None,
default: None,
minimum: None,
maximum: None,
r#enum: None,
r#const: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"uri",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: Some(
::jacquard_common::CowStr::new_static(
"AT-URI reference to the item (e.g., at://did:plc:.../social.showcase.library.item/abc123)",
),
),
format: Some(
::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
),
default: None,
min_length: None,
max_length: None,
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map
},
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"visibilitySettings",
),
::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
description: Some(
::jacquard_common::CowStr::new_static("Visibility preferences"),
),
required: Some(
vec![
::jacquard_common::deps::smol_str::SmolStr::new_static("profileVisibility"),
::jacquard_common::deps::smol_str::SmolStr::new_static("defaultItemVisibility"),
::jacquard_common::deps::smol_str::SmolStr::new_static("defaultCollectionVisibility")
],
),
nullable: None,
properties: {
#[allow(unused_mut)]
let mut map = ::alloc::collections::BTreeMap::new();
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"defaultCollectionVisibility",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: None,
format: None,
default: None,
min_length: None,
max_length: Some(10usize),
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"defaultItemVisibility",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: None,
format: None,
default: None,
min_length: None,
max_length: Some(10usize),
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map.insert(
::jacquard_common::deps::smol_str::SmolStr::new_static(
"profileVisibility",
),
::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
description: None,
format: None,
default: None,
min_length: None,
max_length: Some(10usize),
min_graphemes: None,
max_graphemes: None,
r#enum: None,
r#const: None,
known_values: None,
}),
);
map
},
}),
);
map
},
}
}
impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ActivitySettings<'a> {
fn nsid() -> &'static str {
"social.showcase.defs"
}
fn def_name() -> &'static str {
"activitySettings"
}
fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
lexicon_doc_social_showcase_defs()
}
fn validate(
&self,
) -> ::core::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
{
let value = &self.share_activity;
#[allow(unused_comparisons)]
if <str>::len(value.as_ref()) > 10usize {
return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
path: ::jacquard_lexicon::validation::ValidationPath::from_field(
"share_activity",
),
max: 10usize,
actual: <str>::len(value.as_ref()),
});
}
}
Ok(())
}
}
#[jacquard_derive::lexicon]
#[derive(
serde::Serialize,
serde::Deserialize,
Debug,
Clone,
PartialEq,
Eq,
jacquard_derive::IntoStatic,
Default
)]
#[serde(rename_all = "camelCase")]
pub struct AspectRatio<'a> {
#[serde(skip_serializing_if = "std::option::Option::is_none")]
pub height: std::option::Option<i64>,
#[serde(skip_serializing_if = "std::option::Option::is_none")]
pub width: std::option::Option<i64>,
}
impl<'a> ::jacquard_lexicon::schema::LexiconSchema for AspectRatio<'a> {
fn nsid() -> &'static str {
"social.showcase.defs"
}
fn def_name() -> &'static str {
"aspectRatio"
}
fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
lexicon_doc_social_showcase_defs()
}
fn validate(
&self,
) -> ::core::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
if let Some(ref value) = self.height {
if *value < 1i64 {
return Err(::jacquard_lexicon::validation::ConstraintError::Minimum {
path: ::jacquard_lexicon::validation::ValidationPath::from_field(
"height",
),
min: 1i64,
actual: *value,
});
}
}
if let Some(ref value) = self.width {
if *value < 1i64 {
return Err(::jacquard_lexicon::validation::ConstraintError::Minimum {
path: ::jacquard_lexicon::validation::ValidationPath::from_field(
"width",
),
min: 1i64,
actual: *value,
});
}
}
Ok(())
}
}
#[jacquard_derive::lexicon]
#[derive(
serde::Serialize,
serde::Deserialize,
Debug,
Clone,
PartialEq,
Eq,
jacquard_derive::IntoStatic
)]
#[serde(rename_all = "camelCase")]
pub struct CollectionItem<'a> {
pub added_at: jacquard_common::types::string::Datetime,
pub order: i64,
#[serde(borrow)]
pub uri: jacquard_common::CowStr<'a>,
}
pub mod collection_item_state {
pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
#[allow(unused)]
use ::core::marker::PhantomData;
mod sealed {
pub trait Sealed {}
}
pub trait State: sealed::Sealed {
type Order;
type Uri;
type AddedAt;
}
pub struct Empty(());
impl sealed::Sealed for Empty {}
impl State for Empty {
type Order = Unset;
type Uri = Unset;
type AddedAt = Unset;
}
pub struct SetOrder<S: State = Empty>(PhantomData<fn() -> S>);
impl<S: State> sealed::Sealed for SetOrder<S> {}
impl<S: State> State for SetOrder<S> {
type Order = Set<members::order>;
type Uri = S::Uri;
type AddedAt = S::AddedAt;
}
pub struct SetUri<S: State = Empty>(PhantomData<fn() -> S>);
impl<S: State> sealed::Sealed for SetUri<S> {}
impl<S: State> State for SetUri<S> {
type Order = S::Order;
type Uri = Set<members::uri>;
type AddedAt = S::AddedAt;
}
pub struct SetAddedAt<S: State = Empty>(PhantomData<fn() -> S>);
impl<S: State> sealed::Sealed for SetAddedAt<S> {}
impl<S: State> State for SetAddedAt<S> {
type Order = S::Order;
type Uri = S::Uri;
type AddedAt = Set<members::added_at>;
}
#[allow(non_camel_case_types)]
pub mod members {
pub struct order(());
pub struct uri(());
pub struct added_at(());
}
}
pub struct CollectionItemBuilder<'a, S: collection_item_state::State> {
_phantom_state: ::core::marker::PhantomData<fn() -> S>,
__unsafe_private_named: (
::core::option::Option<jacquard_common::types::string::Datetime>,
::core::option::Option<i64>,
::core::option::Option<jacquard_common::CowStr<'a>>,
),
_phantom: ::core::marker::PhantomData<&'a ()>,
}
impl<'a> CollectionItem<'a> {
pub fn new() -> CollectionItemBuilder<'a, collection_item_state::Empty> {
CollectionItemBuilder::new()
}
}
impl<'a> CollectionItemBuilder<'a, collection_item_state::Empty> {
pub fn new() -> Self {
CollectionItemBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: (None, None, None),
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> CollectionItemBuilder<'a, S>
where
S: collection_item_state::State,
S::AddedAt: collection_item_state::IsUnset,
{
pub fn added_at(
mut self,
value: impl Into<jacquard_common::types::string::Datetime>,
) -> CollectionItemBuilder<'a, collection_item_state::SetAddedAt<S>> {
self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
CollectionItemBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> CollectionItemBuilder<'a, S>
where
S: collection_item_state::State,
S::Order: collection_item_state::IsUnset,
{
pub fn order(
mut self,
value: impl Into<i64>,
) -> CollectionItemBuilder<'a, collection_item_state::SetOrder<S>> {
self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
CollectionItemBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> CollectionItemBuilder<'a, S>
where
S: collection_item_state::State,
S::Uri: collection_item_state::IsUnset,
{
pub fn uri(
mut self,
value: impl Into<jacquard_common::CowStr<'a>>,
) -> CollectionItemBuilder<'a, collection_item_state::SetUri<S>> {
self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into());
CollectionItemBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> CollectionItemBuilder<'a, S>
where
S: collection_item_state::State,
S::Order: collection_item_state::IsSet,
S::Uri: collection_item_state::IsSet,
S::AddedAt: collection_item_state::IsSet,
{
pub fn build(self) -> CollectionItem<'a> {
CollectionItem {
added_at: self.__unsafe_private_named.0.unwrap(),
order: self.__unsafe_private_named.1.unwrap(),
uri: self.__unsafe_private_named.2.unwrap(),
extra_data: Default::default(),
}
}
pub fn build_with_data(
self,
extra_data: std::collections::BTreeMap<
jacquard_common::deps::smol_str::SmolStr,
jacquard_common::types::value::Data<'a>,
>,
) -> CollectionItem<'a> {
CollectionItem {
added_at: self.__unsafe_private_named.0.unwrap(),
order: self.__unsafe_private_named.1.unwrap(),
uri: self.__unsafe_private_named.2.unwrap(),
extra_data: Some(extra_data),
}
}
}
impl<'a> ::jacquard_lexicon::schema::LexiconSchema for CollectionItem<'a> {
fn nsid() -> &'static str {
"social.showcase.defs"
}
fn def_name() -> &'static str {
"collectionItem"
}
fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
lexicon_doc_social_showcase_defs()
}
fn validate(
&self,
) -> ::core::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
{
let value = &self.uri;
#[allow(unused_comparisons)]
if <str>::len(value.as_ref()) > 8192usize {
return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
path: ::jacquard_lexicon::validation::ValidationPath::from_field(
"uri",
),
max: 8192usize,
actual: <str>::len(value.as_ref()),
});
}
}
Ok(())
}
}
#[jacquard_derive::lexicon]
#[derive(
serde::Serialize,
serde::Deserialize,
Debug,
Clone,
PartialEq,
Eq,
jacquard_derive::IntoStatic
)]
#[serde(rename_all = "camelCase")]
pub struct CollectionView<'a> {
#[serde(borrow)]
pub author: crate::social_showcase::ProfileView<'a>,
#[serde(borrow)]
pub cid: jacquard_common::types::string::Cid<'a>,
#[serde(skip_serializing_if = "std::option::Option::is_none")]
#[serde(borrow)]
pub cover_image: std::option::Option<jacquard_common::types::blob::BlobRef<'a>>,
pub created_at: jacquard_common::types::string::Datetime,
#[serde(skip_serializing_if = "std::option::Option::is_none")]
#[serde(borrow)]
pub description: std::option::Option<jacquard_common::CowStr<'a>>,
#[serde(skip_serializing_if = "std::option::Option::is_none")]
pub item_count: std::option::Option<i64>,
#[serde(skip_serializing_if = "std::option::Option::is_none")]
#[serde(borrow)]
pub items: std::option::Option<Vec<crate::social_showcase::ItemView<'a>>>,
#[serde(borrow)]
pub name: jacquard_common::CowStr<'a>,
#[serde(borrow)]
pub tags: Vec<jacquard_common::CowStr<'a>>,
#[serde(borrow)]
pub r#type: jacquard_common::CowStr<'a>,
#[serde(skip_serializing_if = "std::option::Option::is_none")]
pub updated_at: std::option::Option<jacquard_common::types::string::Datetime>,
#[serde(borrow)]
pub uri: jacquard_common::types::string::AtUri<'a>,
#[serde(borrow)]
pub visibility: jacquard_common::CowStr<'a>,
}
pub mod collection_view_state {
pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
#[allow(unused)]
use ::core::marker::PhantomData;
mod sealed {
pub trait Sealed {}
}
pub trait State: sealed::Sealed {
type Author;
type Type;
type Name;
type Uri;
type Cid;
type CreatedAt;
type Tags;
type Visibility;
}
pub struct Empty(());
impl sealed::Sealed for Empty {}
impl State for Empty {
type Author = Unset;
type Type = Unset;
type Name = Unset;
type Uri = Unset;
type Cid = Unset;
type CreatedAt = Unset;
type Tags = Unset;
type Visibility = Unset;
}
pub struct SetAuthor<S: State = Empty>(PhantomData<fn() -> S>);
impl<S: State> sealed::Sealed for SetAuthor<S> {}
impl<S: State> State for SetAuthor<S> {
type Author = Set<members::author>;
type Type = S::Type;
type Name = S::Name;
type Uri = S::Uri;
type Cid = S::Cid;
type CreatedAt = S::CreatedAt;
type Tags = S::Tags;
type Visibility = S::Visibility;
}
pub struct SetType<S: State = Empty>(PhantomData<fn() -> S>);
impl<S: State> sealed::Sealed for SetType<S> {}
impl<S: State> State for SetType<S> {
type Author = S::Author;
type Type = Set<members::r#type>;
type Name = S::Name;
type Uri = S::Uri;
type Cid = S::Cid;
type CreatedAt = S::CreatedAt;
type Tags = S::Tags;
type Visibility = S::Visibility;
}
pub struct SetName<S: State = Empty>(PhantomData<fn() -> S>);
impl<S: State> sealed::Sealed for SetName<S> {}
impl<S: State> State for SetName<S> {
type Author = S::Author;
type Type = S::Type;
type Name = Set<members::name>;
type Uri = S::Uri;
type Cid = S::Cid;
type CreatedAt = S::CreatedAt;
type Tags = S::Tags;
type Visibility = S::Visibility;
}
pub struct SetUri<S: State = Empty>(PhantomData<fn() -> S>);
impl<S: State> sealed::Sealed for SetUri<S> {}
impl<S: State> State for SetUri<S> {
type Author = S::Author;
type Type = S::Type;
type Name = S::Name;
type Uri = Set<members::uri>;
type Cid = S::Cid;
type CreatedAt = S::CreatedAt;
type Tags = S::Tags;
type Visibility = S::Visibility;
}
pub struct SetCid<S: State = Empty>(PhantomData<fn() -> S>);
impl<S: State> sealed::Sealed for SetCid<S> {}
impl<S: State> State for SetCid<S> {
type Author = S::Author;
type Type = S::Type;
type Name = S::Name;
type Uri = S::Uri;
type Cid = Set<members::cid>;
type CreatedAt = S::CreatedAt;
type Tags = S::Tags;
type Visibility = S::Visibility;
}
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 Author = S::Author;
type Type = S::Type;
type Name = S::Name;
type Uri = S::Uri;
type Cid = S::Cid;
type CreatedAt = Set<members::created_at>;
type Tags = S::Tags;
type Visibility = S::Visibility;
}
pub struct SetTags<S: State = Empty>(PhantomData<fn() -> S>);
impl<S: State> sealed::Sealed for SetTags<S> {}
impl<S: State> State for SetTags<S> {
type Author = S::Author;
type Type = S::Type;
type Name = S::Name;
type Uri = S::Uri;
type Cid = S::Cid;
type CreatedAt = S::CreatedAt;
type Tags = Set<members::tags>;
type Visibility = S::Visibility;
}
pub struct SetVisibility<S: State = Empty>(PhantomData<fn() -> S>);
impl<S: State> sealed::Sealed for SetVisibility<S> {}
impl<S: State> State for SetVisibility<S> {
type Author = S::Author;
type Type = S::Type;
type Name = S::Name;
type Uri = S::Uri;
type Cid = S::Cid;
type CreatedAt = S::CreatedAt;
type Tags = S::Tags;
type Visibility = Set<members::visibility>;
}
#[allow(non_camel_case_types)]
pub mod members {
pub struct author(());
pub struct r#type(());
pub struct name(());
pub struct uri(());
pub struct cid(());
pub struct created_at(());
pub struct tags(());
pub struct visibility(());
}
}
pub struct CollectionViewBuilder<'a, S: collection_view_state::State> {
_phantom_state: ::core::marker::PhantomData<fn() -> S>,
__unsafe_private_named: (
::core::option::Option<crate::social_showcase::ProfileView<'a>>,
::core::option::Option<jacquard_common::types::string::Cid<'a>>,
::core::option::Option<jacquard_common::types::blob::BlobRef<'a>>,
::core::option::Option<jacquard_common::types::string::Datetime>,
::core::option::Option<jacquard_common::CowStr<'a>>,
::core::option::Option<i64>,
::core::option::Option<Vec<crate::social_showcase::ItemView<'a>>>,
::core::option::Option<jacquard_common::CowStr<'a>>,
::core::option::Option<Vec<jacquard_common::CowStr<'a>>>,
::core::option::Option<jacquard_common::CowStr<'a>>,
::core::option::Option<jacquard_common::types::string::Datetime>,
::core::option::Option<jacquard_common::types::string::AtUri<'a>>,
::core::option::Option<jacquard_common::CowStr<'a>>,
),
_phantom: ::core::marker::PhantomData<&'a ()>,
}
impl<'a> CollectionView<'a> {
pub fn new() -> CollectionViewBuilder<'a, collection_view_state::Empty> {
CollectionViewBuilder::new()
}
}
impl<'a> CollectionViewBuilder<'a, collection_view_state::Empty> {
pub fn new() -> Self {
CollectionViewBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: (
None,
None,
None,
None,
None,
None,
None,
None,
None,
None,
None,
None,
None,
),
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> CollectionViewBuilder<'a, S>
where
S: collection_view_state::State,
S::Author: collection_view_state::IsUnset,
{
pub fn author(
mut self,
value: impl Into<crate::social_showcase::ProfileView<'a>>,
) -> CollectionViewBuilder<'a, collection_view_state::SetAuthor<S>> {
self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
CollectionViewBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> CollectionViewBuilder<'a, S>
where
S: collection_view_state::State,
S::Cid: collection_view_state::IsUnset,
{
pub fn cid(
mut self,
value: impl Into<jacquard_common::types::string::Cid<'a>>,
) -> CollectionViewBuilder<'a, collection_view_state::SetCid<S>> {
self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
CollectionViewBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S: collection_view_state::State> CollectionViewBuilder<'a, S> {
pub fn cover_image(
mut self,
value: impl Into<Option<jacquard_common::types::blob::BlobRef<'a>>>,
) -> Self {
self.__unsafe_private_named.2 = value.into();
self
}
pub fn maybe_cover_image(
mut self,
value: Option<jacquard_common::types::blob::BlobRef<'a>>,
) -> Self {
self.__unsafe_private_named.2 = value;
self
}
}
impl<'a, S> CollectionViewBuilder<'a, S>
where
S: collection_view_state::State,
S::CreatedAt: collection_view_state::IsUnset,
{
pub fn created_at(
mut self,
value: impl Into<jacquard_common::types::string::Datetime>,
) -> CollectionViewBuilder<'a, collection_view_state::SetCreatedAt<S>> {
self.__unsafe_private_named.3 = ::core::option::Option::Some(value.into());
CollectionViewBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S: collection_view_state::State> CollectionViewBuilder<'a, S> {
pub fn description(
mut self,
value: impl Into<Option<jacquard_common::CowStr<'a>>>,
) -> Self {
self.__unsafe_private_named.4 = value.into();
self
}
pub fn maybe_description(
mut self,
value: Option<jacquard_common::CowStr<'a>>,
) -> Self {
self.__unsafe_private_named.4 = value;
self
}
}
impl<'a, S: collection_view_state::State> CollectionViewBuilder<'a, S> {
pub fn item_count(mut self, value: impl Into<Option<i64>>) -> Self {
self.__unsafe_private_named.5 = value.into();
self
}
pub fn maybe_item_count(mut self, value: Option<i64>) -> Self {
self.__unsafe_private_named.5 = value;
self
}
}
impl<'a, S: collection_view_state::State> CollectionViewBuilder<'a, S> {
pub fn items(
mut self,
value: impl Into<Option<Vec<crate::social_showcase::ItemView<'a>>>>,
) -> Self {
self.__unsafe_private_named.6 = value.into();
self
}
pub fn maybe_items(
mut self,
value: Option<Vec<crate::social_showcase::ItemView<'a>>>,
) -> Self {
self.__unsafe_private_named.6 = value;
self
}
}
impl<'a, S> CollectionViewBuilder<'a, S>
where
S: collection_view_state::State,
S::Name: collection_view_state::IsUnset,
{
pub fn name(
mut self,
value: impl Into<jacquard_common::CowStr<'a>>,
) -> CollectionViewBuilder<'a, collection_view_state::SetName<S>> {
self.__unsafe_private_named.7 = ::core::option::Option::Some(value.into());
CollectionViewBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> CollectionViewBuilder<'a, S>
where
S: collection_view_state::State,
S::Tags: collection_view_state::IsUnset,
{
pub fn tags(
mut self,
value: impl Into<Vec<jacquard_common::CowStr<'a>>>,
) -> CollectionViewBuilder<'a, collection_view_state::SetTags<S>> {
self.__unsafe_private_named.8 = ::core::option::Option::Some(value.into());
CollectionViewBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> CollectionViewBuilder<'a, S>
where
S: collection_view_state::State,
S::Type: collection_view_state::IsUnset,
{
pub fn r#type(
mut self,
value: impl Into<jacquard_common::CowStr<'a>>,
) -> CollectionViewBuilder<'a, collection_view_state::SetType<S>> {
self.__unsafe_private_named.9 = ::core::option::Option::Some(value.into());
CollectionViewBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S: collection_view_state::State> CollectionViewBuilder<'a, S> {
pub fn updated_at(
mut self,
value: impl Into<Option<jacquard_common::types::string::Datetime>>,
) -> Self {
self.__unsafe_private_named.10 = value.into();
self
}
pub fn maybe_updated_at(
mut self,
value: Option<jacquard_common::types::string::Datetime>,
) -> Self {
self.__unsafe_private_named.10 = value;
self
}
}
impl<'a, S> CollectionViewBuilder<'a, S>
where
S: collection_view_state::State,
S::Uri: collection_view_state::IsUnset,
{
pub fn uri(
mut self,
value: impl Into<jacquard_common::types::string::AtUri<'a>>,
) -> CollectionViewBuilder<'a, collection_view_state::SetUri<S>> {
self.__unsafe_private_named.11 = ::core::option::Option::Some(value.into());
CollectionViewBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> CollectionViewBuilder<'a, S>
where
S: collection_view_state::State,
S::Visibility: collection_view_state::IsUnset,
{
pub fn visibility(
mut self,
value: impl Into<jacquard_common::CowStr<'a>>,
) -> CollectionViewBuilder<'a, collection_view_state::SetVisibility<S>> {
self.__unsafe_private_named.12 = ::core::option::Option::Some(value.into());
CollectionViewBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> CollectionViewBuilder<'a, S>
where
S: collection_view_state::State,
S::Author: collection_view_state::IsSet,
S::Type: collection_view_state::IsSet,
S::Name: collection_view_state::IsSet,
S::Uri: collection_view_state::IsSet,
S::Cid: collection_view_state::IsSet,
S::CreatedAt: collection_view_state::IsSet,
S::Tags: collection_view_state::IsSet,
S::Visibility: collection_view_state::IsSet,
{
pub fn build(self) -> CollectionView<'a> {
CollectionView {
author: self.__unsafe_private_named.0.unwrap(),
cid: self.__unsafe_private_named.1.unwrap(),
cover_image: self.__unsafe_private_named.2,
created_at: self.__unsafe_private_named.3.unwrap(),
description: self.__unsafe_private_named.4,
item_count: self.__unsafe_private_named.5,
items: self.__unsafe_private_named.6,
name: self.__unsafe_private_named.7.unwrap(),
tags: self.__unsafe_private_named.8.unwrap(),
r#type: self.__unsafe_private_named.9.unwrap(),
updated_at: self.__unsafe_private_named.10,
uri: self.__unsafe_private_named.11.unwrap(),
visibility: self.__unsafe_private_named.12.unwrap(),
extra_data: Default::default(),
}
}
pub fn build_with_data(
self,
extra_data: std::collections::BTreeMap<
jacquard_common::deps::smol_str::SmolStr,
jacquard_common::types::value::Data<'a>,
>,
) -> CollectionView<'a> {
CollectionView {
author: self.__unsafe_private_named.0.unwrap(),
cid: self.__unsafe_private_named.1.unwrap(),
cover_image: self.__unsafe_private_named.2,
created_at: self.__unsafe_private_named.3.unwrap(),
description: self.__unsafe_private_named.4,
item_count: self.__unsafe_private_named.5,
items: self.__unsafe_private_named.6,
name: self.__unsafe_private_named.7.unwrap(),
tags: self.__unsafe_private_named.8.unwrap(),
r#type: self.__unsafe_private_named.9.unwrap(),
updated_at: self.__unsafe_private_named.10,
uri: self.__unsafe_private_named.11.unwrap(),
visibility: self.__unsafe_private_named.12.unwrap(),
extra_data: Some(extra_data),
}
}
}
impl<'a> ::jacquard_lexicon::schema::LexiconSchema for CollectionView<'a> {
fn nsid() -> &'static str {
"social.showcase.defs"
}
fn def_name() -> &'static str {
"collectionView"
}
fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
lexicon_doc_social_showcase_defs()
}
fn validate(
&self,
) -> ::core::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
if let Some(ref value) = self.description {
#[allow(unused_comparisons)]
if <str>::len(value.as_ref()) > 1000usize {
return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
path: ::jacquard_lexicon::validation::ValidationPath::from_field(
"description",
),
max: 1000usize,
actual: <str>::len(value.as_ref()),
});
}
}
{
let value = &self.name;
#[allow(unused_comparisons)]
if <str>::len(value.as_ref()) > 200usize {
return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
path: ::jacquard_lexicon::validation::ValidationPath::from_field(
"name",
),
max: 200usize,
actual: <str>::len(value.as_ref()),
});
}
}
{
let value = &self.r#type;
#[allow(unused_comparisons)]
if <str>::len(value.as_ref()) > 20usize {
return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
path: ::jacquard_lexicon::validation::ValidationPath::from_field(
"type",
),
max: 20usize,
actual: <str>::len(value.as_ref()),
});
}
}
{
let value = &self.visibility;
#[allow(unused_comparisons)]
if <str>::len(value.as_ref()) > 10usize {
return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
path: ::jacquard_lexicon::validation::ValidationPath::from_field(
"visibility",
),
max: 10usize,
actual: <str>::len(value.as_ref()),
});
}
}
Ok(())
}
}
#[jacquard_derive::lexicon]
#[derive(
serde::Serialize,
serde::Deserialize,
Debug,
Clone,
PartialEq,
Eq,
jacquard_derive::IntoStatic,
Default
)]
#[serde(rename_all = "camelCase")]
pub struct DisplaySettings<'a> {
#[serde(skip_serializing_if = "std::option::Option::is_none")]
#[serde(borrow)]
pub grid_layout: std::option::Option<DisplaySettingsGridLayout<'a>>,
#[serde(skip_serializing_if = "std::option::Option::is_none")]
#[serde(borrow)]
pub theme: std::option::Option<DisplaySettingsTheme<'a>>,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum DisplaySettingsGridLayout<'a> {
Compact,
Spacious,
Other(jacquard_common::CowStr<'a>),
}
impl<'a> DisplaySettingsGridLayout<'a> {
pub fn as_str(&self) -> &str {
match self {
Self::Compact => "compact",
Self::Spacious => "spacious",
Self::Other(s) => s.as_ref(),
}
}
}
impl<'a> From<&'a str> for DisplaySettingsGridLayout<'a> {
fn from(s: &'a str) -> Self {
match s {
"compact" => Self::Compact,
"spacious" => Self::Spacious,
_ => Self::Other(jacquard_common::CowStr::from(s)),
}
}
}
impl<'a> From<String> for DisplaySettingsGridLayout<'a> {
fn from(s: String) -> Self {
match s.as_str() {
"compact" => Self::Compact,
"spacious" => Self::Spacious,
_ => Self::Other(jacquard_common::CowStr::from(s)),
}
}
}
impl<'a> core::fmt::Display for DisplaySettingsGridLayout<'a> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "{}", self.as_str())
}
}
impl<'a> AsRef<str> for DisplaySettingsGridLayout<'a> {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl<'a> serde::Serialize for DisplaySettingsGridLayout<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serializer.serialize_str(self.as_str())
}
}
impl<'de, 'a> serde::Deserialize<'de> for DisplaySettingsGridLayout<'a>
where
'de: 'a,
{
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let s = <&'de str>::deserialize(deserializer)?;
Ok(Self::from(s))
}
}
impl<'a> Default for DisplaySettingsGridLayout<'a> {
fn default() -> Self {
Self::Other(Default::default())
}
}
impl jacquard_common::IntoStatic for DisplaySettingsGridLayout<'_> {
type Output = DisplaySettingsGridLayout<'static>;
fn into_static(self) -> Self::Output {
match self {
DisplaySettingsGridLayout::Compact => DisplaySettingsGridLayout::Compact,
DisplaySettingsGridLayout::Spacious => DisplaySettingsGridLayout::Spacious,
DisplaySettingsGridLayout::Other(v) => {
DisplaySettingsGridLayout::Other(v.into_static())
}
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum DisplaySettingsTheme<'a> {
Light,
Dark,
Auto,
Other(jacquard_common::CowStr<'a>),
}
impl<'a> DisplaySettingsTheme<'a> {
pub fn as_str(&self) -> &str {
match self {
Self::Light => "light",
Self::Dark => "dark",
Self::Auto => "auto",
Self::Other(s) => s.as_ref(),
}
}
}
impl<'a> From<&'a str> for DisplaySettingsTheme<'a> {
fn from(s: &'a str) -> Self {
match s {
"light" => Self::Light,
"dark" => Self::Dark,
"auto" => Self::Auto,
_ => Self::Other(jacquard_common::CowStr::from(s)),
}
}
}
impl<'a> From<String> for DisplaySettingsTheme<'a> {
fn from(s: String) -> Self {
match s.as_str() {
"light" => Self::Light,
"dark" => Self::Dark,
"auto" => Self::Auto,
_ => Self::Other(jacquard_common::CowStr::from(s)),
}
}
}
impl<'a> core::fmt::Display for DisplaySettingsTheme<'a> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "{}", self.as_str())
}
}
impl<'a> AsRef<str> for DisplaySettingsTheme<'a> {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl<'a> serde::Serialize for DisplaySettingsTheme<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serializer.serialize_str(self.as_str())
}
}
impl<'de, 'a> serde::Deserialize<'de> for DisplaySettingsTheme<'a>
where
'de: 'a,
{
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let s = <&'de str>::deserialize(deserializer)?;
Ok(Self::from(s))
}
}
impl<'a> Default for DisplaySettingsTheme<'a> {
fn default() -> Self {
Self::Other(Default::default())
}
}
impl jacquard_common::IntoStatic for DisplaySettingsTheme<'_> {
type Output = DisplaySettingsTheme<'static>;
fn into_static(self) -> Self::Output {
match self {
DisplaySettingsTheme::Light => DisplaySettingsTheme::Light,
DisplaySettingsTheme::Dark => DisplaySettingsTheme::Dark,
DisplaySettingsTheme::Auto => DisplaySettingsTheme::Auto,
DisplaySettingsTheme::Other(v) => {
DisplaySettingsTheme::Other(v.into_static())
}
}
}
}
impl<'a> ::jacquard_lexicon::schema::LexiconSchema for DisplaySettings<'a> {
fn nsid() -> &'static str {
"social.showcase.defs"
}
fn def_name() -> &'static str {
"displaySettings"
}
fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
lexicon_doc_social_showcase_defs()
}
fn validate(
&self,
) -> ::core::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
if let Some(ref value) = self.grid_layout {
#[allow(unused_comparisons)]
if <str>::len(value.as_ref()) > 10usize {
return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
path: ::jacquard_lexicon::validation::ValidationPath::from_field(
"grid_layout",
),
max: 10usize,
actual: <str>::len(value.as_ref()),
});
}
}
if let Some(ref value) = self.theme {
#[allow(unused_comparisons)]
if <str>::len(value.as_ref()) > 10usize {
return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
path: ::jacquard_lexicon::validation::ValidationPath::from_field(
"theme",
),
max: 10usize,
actual: <str>::len(value.as_ref()),
});
}
}
Ok(())
}
}
#[jacquard_derive::lexicon]
#[derive(
serde::Serialize,
serde::Deserialize,
Debug,
Clone,
PartialEq,
Eq,
jacquard_derive::IntoStatic
)]
#[serde(rename_all = "camelCase")]
pub struct ItemImage<'a> {
#[serde(skip_serializing_if = "std::option::Option::is_none")]
#[serde(borrow)]
pub alt: std::option::Option<jacquard_common::CowStr<'a>>,
#[serde(skip_serializing_if = "std::option::Option::is_none")]
#[serde(borrow)]
pub aspect_ratio: std::option::Option<crate::social_showcase::AspectRatio<'a>>,
#[serde(borrow)]
pub blob: jacquard_common::types::blob::BlobRef<'a>,
}
pub mod item_image_state {
pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
#[allow(unused)]
use ::core::marker::PhantomData;
mod sealed {
pub trait Sealed {}
}
pub trait State: sealed::Sealed {
type Blob;
}
pub struct Empty(());
impl sealed::Sealed for Empty {}
impl State for Empty {
type Blob = Unset;
}
pub struct SetBlob<S: State = Empty>(PhantomData<fn() -> S>);
impl<S: State> sealed::Sealed for SetBlob<S> {}
impl<S: State> State for SetBlob<S> {
type Blob = Set<members::blob>;
}
#[allow(non_camel_case_types)]
pub mod members {
pub struct blob(());
}
}
pub struct ItemImageBuilder<'a, S: item_image_state::State> {
_phantom_state: ::core::marker::PhantomData<fn() -> S>,
__unsafe_private_named: (
::core::option::Option<jacquard_common::CowStr<'a>>,
::core::option::Option<crate::social_showcase::AspectRatio<'a>>,
::core::option::Option<jacquard_common::types::blob::BlobRef<'a>>,
),
_phantom: ::core::marker::PhantomData<&'a ()>,
}
impl<'a> ItemImage<'a> {
pub fn new() -> ItemImageBuilder<'a, item_image_state::Empty> {
ItemImageBuilder::new()
}
}
impl<'a> ItemImageBuilder<'a, item_image_state::Empty> {
pub fn new() -> Self {
ItemImageBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: (None, None, None),
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S: item_image_state::State> ItemImageBuilder<'a, S> {
pub fn alt(mut self, value: impl Into<Option<jacquard_common::CowStr<'a>>>) -> Self {
self.__unsafe_private_named.0 = value.into();
self
}
pub fn maybe_alt(mut self, value: Option<jacquard_common::CowStr<'a>>) -> Self {
self.__unsafe_private_named.0 = value;
self
}
}
impl<'a, S: item_image_state::State> ItemImageBuilder<'a, S> {
pub fn aspect_ratio(
mut self,
value: impl Into<Option<crate::social_showcase::AspectRatio<'a>>>,
) -> Self {
self.__unsafe_private_named.1 = value.into();
self
}
pub fn maybe_aspect_ratio(
mut self,
value: Option<crate::social_showcase::AspectRatio<'a>>,
) -> Self {
self.__unsafe_private_named.1 = value;
self
}
}
impl<'a, S> ItemImageBuilder<'a, S>
where
S: item_image_state::State,
S::Blob: item_image_state::IsUnset,
{
pub fn blob(
mut self,
value: impl Into<jacquard_common::types::blob::BlobRef<'a>>,
) -> ItemImageBuilder<'a, item_image_state::SetBlob<S>> {
self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into());
ItemImageBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> ItemImageBuilder<'a, S>
where
S: item_image_state::State,
S::Blob: item_image_state::IsSet,
{
pub fn build(self) -> ItemImage<'a> {
ItemImage {
alt: self.__unsafe_private_named.0,
aspect_ratio: self.__unsafe_private_named.1,
blob: self.__unsafe_private_named.2.unwrap(),
extra_data: Default::default(),
}
}
pub fn build_with_data(
self,
extra_data: std::collections::BTreeMap<
jacquard_common::deps::smol_str::SmolStr,
jacquard_common::types::value::Data<'a>,
>,
) -> ItemImage<'a> {
ItemImage {
alt: self.__unsafe_private_named.0,
aspect_ratio: self.__unsafe_private_named.1,
blob: self.__unsafe_private_named.2.unwrap(),
extra_data: Some(extra_data),
}
}
}
impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ItemImage<'a> {
fn nsid() -> &'static str {
"social.showcase.defs"
}
fn def_name() -> &'static str {
"itemImage"
}
fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
lexicon_doc_social_showcase_defs()
}
fn validate(
&self,
) -> ::core::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
if let Some(ref value) = self.alt {
#[allow(unused_comparisons)]
if <str>::len(value.as_ref()) > 300usize {
return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
path: ::jacquard_lexicon::validation::ValidationPath::from_field(
"alt",
),
max: 300usize,
actual: <str>::len(value.as_ref()),
});
}
}
{
let value = &self.blob;
{
let size = value.blob().size;
if size > 5000000usize {
return Err(::jacquard_lexicon::validation::ConstraintError::BlobTooLarge {
path: ::jacquard_lexicon::validation::ValidationPath::from_field(
"blob",
),
max: 5000000usize,
actual: size,
});
}
}
}
{
let value = &self.blob;
{
let mime = value.blob().mime_type.as_str();
let accepted: &[&str] = &["image/png", "image/jpeg", "image/webp"];
let matched = accepted
.iter()
.any(|pattern| {
if *pattern == "*/*" {
true
} else if pattern.ends_with("/*") {
let prefix = &pattern[..pattern.len() - 2];
mime.starts_with(prefix)
&& mime.as_bytes().get(prefix.len()) == Some(&b'/')
} else {
mime == *pattern
}
});
if !matched {
return Err(::jacquard_lexicon::validation::ConstraintError::BlobMimeTypeNotAccepted {
path: ::jacquard_lexicon::validation::ValidationPath::from_field(
"blob",
),
accepted: vec![
"image/png".to_string(), "image/jpeg".to_string(),
"image/webp".to_string()
],
actual: mime.to_string(),
});
}
}
}
Ok(())
}
}
#[jacquard_derive::lexicon]
#[derive(
serde::Serialize,
serde::Deserialize,
Debug,
Clone,
PartialEq,
Eq,
jacquard_derive::IntoStatic
)]
#[serde(rename_all = "camelCase")]
pub struct ItemView<'a> {
#[serde(borrow)]
pub author: crate::social_showcase::ProfileView<'a>,
#[serde(skip_serializing_if = "std::option::Option::is_none")]
#[serde(borrow)]
pub category: std::option::Option<jacquard_common::CowStr<'a>>,
#[serde(borrow)]
pub cid: jacquard_common::types::string::Cid<'a>,
pub created_at: jacquard_common::types::string::Datetime,
#[serde(skip_serializing_if = "std::option::Option::is_none")]
#[serde(borrow)]
pub description: std::option::Option<jacquard_common::CowStr<'a>>,
#[serde(skip_serializing_if = "std::option::Option::is_none")]
#[serde(borrow)]
pub external_link: std::option::Option<jacquard_common::types::string::UriValue<'a>>,
#[serde(borrow)]
pub images: Vec<crate::social_showcase::ItemImage<'a>>,
#[serde(skip_serializing_if = "std::option::Option::is_none")]
#[serde(borrow)]
pub metadata: std::option::Option<jacquard_common::types::value::Data<'a>>,
#[serde(skip_serializing_if = "std::option::Option::is_none")]
pub reaction_count: std::option::Option<i64>,
#[serde(borrow)]
pub tags: Vec<jacquard_common::CowStr<'a>>,
#[serde(borrow)]
pub title: jacquard_common::CowStr<'a>,
#[serde(skip_serializing_if = "std::option::Option::is_none")]
pub updated_at: std::option::Option<jacquard_common::types::string::Datetime>,
#[serde(borrow)]
pub uri: jacquard_common::types::string::AtUri<'a>,
#[serde(borrow)]
pub visibility: jacquard_common::CowStr<'a>,
}
pub mod item_view_state {
pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
#[allow(unused)]
use ::core::marker::PhantomData;
mod sealed {
pub trait Sealed {}
}
pub trait State: sealed::Sealed {
type Cid;
type Visibility;
type Tags;
type Author;
type Uri;
type Images;
type Title;
type CreatedAt;
}
pub struct Empty(());
impl sealed::Sealed for Empty {}
impl State for Empty {
type Cid = Unset;
type Visibility = Unset;
type Tags = Unset;
type Author = Unset;
type Uri = Unset;
type Images = Unset;
type Title = Unset;
type CreatedAt = Unset;
}
pub struct SetCid<S: State = Empty>(PhantomData<fn() -> S>);
impl<S: State> sealed::Sealed for SetCid<S> {}
impl<S: State> State for SetCid<S> {
type Cid = Set<members::cid>;
type Visibility = S::Visibility;
type Tags = S::Tags;
type Author = S::Author;
type Uri = S::Uri;
type Images = S::Images;
type Title = S::Title;
type CreatedAt = S::CreatedAt;
}
pub struct SetVisibility<S: State = Empty>(PhantomData<fn() -> S>);
impl<S: State> sealed::Sealed for SetVisibility<S> {}
impl<S: State> State for SetVisibility<S> {
type Cid = S::Cid;
type Visibility = Set<members::visibility>;
type Tags = S::Tags;
type Author = S::Author;
type Uri = S::Uri;
type Images = S::Images;
type Title = S::Title;
type CreatedAt = S::CreatedAt;
}
pub struct SetTags<S: State = Empty>(PhantomData<fn() -> S>);
impl<S: State> sealed::Sealed for SetTags<S> {}
impl<S: State> State for SetTags<S> {
type Cid = S::Cid;
type Visibility = S::Visibility;
type Tags = Set<members::tags>;
type Author = S::Author;
type Uri = S::Uri;
type Images = S::Images;
type Title = S::Title;
type CreatedAt = S::CreatedAt;
}
pub struct SetAuthor<S: State = Empty>(PhantomData<fn() -> S>);
impl<S: State> sealed::Sealed for SetAuthor<S> {}
impl<S: State> State for SetAuthor<S> {
type Cid = S::Cid;
type Visibility = S::Visibility;
type Tags = S::Tags;
type Author = Set<members::author>;
type Uri = S::Uri;
type Images = S::Images;
type Title = S::Title;
type CreatedAt = S::CreatedAt;
}
pub struct SetUri<S: State = Empty>(PhantomData<fn() -> S>);
impl<S: State> sealed::Sealed for SetUri<S> {}
impl<S: State> State for SetUri<S> {
type Cid = S::Cid;
type Visibility = S::Visibility;
type Tags = S::Tags;
type Author = S::Author;
type Uri = Set<members::uri>;
type Images = S::Images;
type Title = S::Title;
type CreatedAt = S::CreatedAt;
}
pub struct SetImages<S: State = Empty>(PhantomData<fn() -> S>);
impl<S: State> sealed::Sealed for SetImages<S> {}
impl<S: State> State for SetImages<S> {
type Cid = S::Cid;
type Visibility = S::Visibility;
type Tags = S::Tags;
type Author = S::Author;
type Uri = S::Uri;
type Images = Set<members::images>;
type Title = S::Title;
type CreatedAt = S::CreatedAt;
}
pub struct SetTitle<S: State = Empty>(PhantomData<fn() -> S>);
impl<S: State> sealed::Sealed for SetTitle<S> {}
impl<S: State> State for SetTitle<S> {
type Cid = S::Cid;
type Visibility = S::Visibility;
type Tags = S::Tags;
type Author = S::Author;
type Uri = S::Uri;
type Images = S::Images;
type Title = Set<members::title>;
type CreatedAt = S::CreatedAt;
}
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 Cid = S::Cid;
type Visibility = S::Visibility;
type Tags = S::Tags;
type Author = S::Author;
type Uri = S::Uri;
type Images = S::Images;
type Title = S::Title;
type CreatedAt = Set<members::created_at>;
}
#[allow(non_camel_case_types)]
pub mod members {
pub struct cid(());
pub struct visibility(());
pub struct tags(());
pub struct author(());
pub struct uri(());
pub struct images(());
pub struct title(());
pub struct created_at(());
}
}
pub struct ItemViewBuilder<'a, S: item_view_state::State> {
_phantom_state: ::core::marker::PhantomData<fn() -> S>,
__unsafe_private_named: (
::core::option::Option<crate::social_showcase::ProfileView<'a>>,
::core::option::Option<jacquard_common::CowStr<'a>>,
::core::option::Option<jacquard_common::types::string::Cid<'a>>,
::core::option::Option<jacquard_common::types::string::Datetime>,
::core::option::Option<jacquard_common::CowStr<'a>>,
::core::option::Option<jacquard_common::types::string::UriValue<'a>>,
::core::option::Option<Vec<crate::social_showcase::ItemImage<'a>>>,
::core::option::Option<jacquard_common::types::value::Data<'a>>,
::core::option::Option<i64>,
::core::option::Option<Vec<jacquard_common::CowStr<'a>>>,
::core::option::Option<jacquard_common::CowStr<'a>>,
::core::option::Option<jacquard_common::types::string::Datetime>,
::core::option::Option<jacquard_common::types::string::AtUri<'a>>,
::core::option::Option<jacquard_common::CowStr<'a>>,
),
_phantom: ::core::marker::PhantomData<&'a ()>,
}
impl<'a> ItemView<'a> {
pub fn new() -> ItemViewBuilder<'a, item_view_state::Empty> {
ItemViewBuilder::new()
}
}
impl<'a> ItemViewBuilder<'a, item_view_state::Empty> {
pub fn new() -> Self {
ItemViewBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: (
None,
None,
None,
None,
None,
None,
None,
None,
None,
None,
None,
None,
None,
None,
),
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> ItemViewBuilder<'a, S>
where
S: item_view_state::State,
S::Author: item_view_state::IsUnset,
{
pub fn author(
mut self,
value: impl Into<crate::social_showcase::ProfileView<'a>>,
) -> ItemViewBuilder<'a, item_view_state::SetAuthor<S>> {
self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
ItemViewBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S: item_view_state::State> ItemViewBuilder<'a, S> {
pub fn category(
mut self,
value: impl Into<Option<jacquard_common::CowStr<'a>>>,
) -> Self {
self.__unsafe_private_named.1 = value.into();
self
}
pub fn maybe_category(mut self, value: Option<jacquard_common::CowStr<'a>>) -> Self {
self.__unsafe_private_named.1 = value;
self
}
}
impl<'a, S> ItemViewBuilder<'a, S>
where
S: item_view_state::State,
S::Cid: item_view_state::IsUnset,
{
pub fn cid(
mut self,
value: impl Into<jacquard_common::types::string::Cid<'a>>,
) -> ItemViewBuilder<'a, item_view_state::SetCid<S>> {
self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into());
ItemViewBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> ItemViewBuilder<'a, S>
where
S: item_view_state::State,
S::CreatedAt: item_view_state::IsUnset,
{
pub fn created_at(
mut self,
value: impl Into<jacquard_common::types::string::Datetime>,
) -> ItemViewBuilder<'a, item_view_state::SetCreatedAt<S>> {
self.__unsafe_private_named.3 = ::core::option::Option::Some(value.into());
ItemViewBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S: item_view_state::State> ItemViewBuilder<'a, S> {
pub fn description(
mut self,
value: impl Into<Option<jacquard_common::CowStr<'a>>>,
) -> Self {
self.__unsafe_private_named.4 = value.into();
self
}
pub fn maybe_description(
mut self,
value: Option<jacquard_common::CowStr<'a>>,
) -> Self {
self.__unsafe_private_named.4 = value;
self
}
}
impl<'a, S: item_view_state::State> ItemViewBuilder<'a, S> {
pub fn external_link(
mut self,
value: impl Into<Option<jacquard_common::types::string::UriValue<'a>>>,
) -> Self {
self.__unsafe_private_named.5 = value.into();
self
}
pub fn maybe_external_link(
mut self,
value: Option<jacquard_common::types::string::UriValue<'a>>,
) -> Self {
self.__unsafe_private_named.5 = value;
self
}
}
impl<'a, S> ItemViewBuilder<'a, S>
where
S: item_view_state::State,
S::Images: item_view_state::IsUnset,
{
pub fn images(
mut self,
value: impl Into<Vec<crate::social_showcase::ItemImage<'a>>>,
) -> ItemViewBuilder<'a, item_view_state::SetImages<S>> {
self.__unsafe_private_named.6 = ::core::option::Option::Some(value.into());
ItemViewBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S: item_view_state::State> ItemViewBuilder<'a, S> {
pub fn metadata(
mut self,
value: impl Into<Option<jacquard_common::types::value::Data<'a>>>,
) -> Self {
self.__unsafe_private_named.7 = value.into();
self
}
pub fn maybe_metadata(
mut self,
value: Option<jacquard_common::types::value::Data<'a>>,
) -> Self {
self.__unsafe_private_named.7 = value;
self
}
}
impl<'a, S: item_view_state::State> ItemViewBuilder<'a, S> {
pub fn reaction_count(mut self, value: impl Into<Option<i64>>) -> Self {
self.__unsafe_private_named.8 = value.into();
self
}
pub fn maybe_reaction_count(mut self, value: Option<i64>) -> Self {
self.__unsafe_private_named.8 = value;
self
}
}
impl<'a, S> ItemViewBuilder<'a, S>
where
S: item_view_state::State,
S::Tags: item_view_state::IsUnset,
{
pub fn tags(
mut self,
value: impl Into<Vec<jacquard_common::CowStr<'a>>>,
) -> ItemViewBuilder<'a, item_view_state::SetTags<S>> {
self.__unsafe_private_named.9 = ::core::option::Option::Some(value.into());
ItemViewBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> ItemViewBuilder<'a, S>
where
S: item_view_state::State,
S::Title: item_view_state::IsUnset,
{
pub fn title(
mut self,
value: impl Into<jacquard_common::CowStr<'a>>,
) -> ItemViewBuilder<'a, item_view_state::SetTitle<S>> {
self.__unsafe_private_named.10 = ::core::option::Option::Some(value.into());
ItemViewBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S: item_view_state::State> ItemViewBuilder<'a, S> {
pub fn updated_at(
mut self,
value: impl Into<Option<jacquard_common::types::string::Datetime>>,
) -> Self {
self.__unsafe_private_named.11 = value.into();
self
}
pub fn maybe_updated_at(
mut self,
value: Option<jacquard_common::types::string::Datetime>,
) -> Self {
self.__unsafe_private_named.11 = value;
self
}
}
impl<'a, S> ItemViewBuilder<'a, S>
where
S: item_view_state::State,
S::Uri: item_view_state::IsUnset,
{
pub fn uri(
mut self,
value: impl Into<jacquard_common::types::string::AtUri<'a>>,
) -> ItemViewBuilder<'a, item_view_state::SetUri<S>> {
self.__unsafe_private_named.12 = ::core::option::Option::Some(value.into());
ItemViewBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> ItemViewBuilder<'a, S>
where
S: item_view_state::State,
S::Visibility: item_view_state::IsUnset,
{
pub fn visibility(
mut self,
value: impl Into<jacquard_common::CowStr<'a>>,
) -> ItemViewBuilder<'a, item_view_state::SetVisibility<S>> {
self.__unsafe_private_named.13 = ::core::option::Option::Some(value.into());
ItemViewBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> ItemViewBuilder<'a, S>
where
S: item_view_state::State,
S::Cid: item_view_state::IsSet,
S::Visibility: item_view_state::IsSet,
S::Tags: item_view_state::IsSet,
S::Author: item_view_state::IsSet,
S::Uri: item_view_state::IsSet,
S::Images: item_view_state::IsSet,
S::Title: item_view_state::IsSet,
S::CreatedAt: item_view_state::IsSet,
{
pub fn build(self) -> ItemView<'a> {
ItemView {
author: self.__unsafe_private_named.0.unwrap(),
category: self.__unsafe_private_named.1,
cid: self.__unsafe_private_named.2.unwrap(),
created_at: self.__unsafe_private_named.3.unwrap(),
description: self.__unsafe_private_named.4,
external_link: self.__unsafe_private_named.5,
images: self.__unsafe_private_named.6.unwrap(),
metadata: self.__unsafe_private_named.7,
reaction_count: self.__unsafe_private_named.8,
tags: self.__unsafe_private_named.9.unwrap(),
title: self.__unsafe_private_named.10.unwrap(),
updated_at: self.__unsafe_private_named.11,
uri: self.__unsafe_private_named.12.unwrap(),
visibility: self.__unsafe_private_named.13.unwrap(),
extra_data: Default::default(),
}
}
pub fn build_with_data(
self,
extra_data: std::collections::BTreeMap<
jacquard_common::deps::smol_str::SmolStr,
jacquard_common::types::value::Data<'a>,
>,
) -> ItemView<'a> {
ItemView {
author: self.__unsafe_private_named.0.unwrap(),
category: self.__unsafe_private_named.1,
cid: self.__unsafe_private_named.2.unwrap(),
created_at: self.__unsafe_private_named.3.unwrap(),
description: self.__unsafe_private_named.4,
external_link: self.__unsafe_private_named.5,
images: self.__unsafe_private_named.6.unwrap(),
metadata: self.__unsafe_private_named.7,
reaction_count: self.__unsafe_private_named.8,
tags: self.__unsafe_private_named.9.unwrap(),
title: self.__unsafe_private_named.10.unwrap(),
updated_at: self.__unsafe_private_named.11,
uri: self.__unsafe_private_named.12.unwrap(),
visibility: self.__unsafe_private_named.13.unwrap(),
extra_data: Some(extra_data),
}
}
}
impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ItemView<'a> {
fn nsid() -> &'static str {
"social.showcase.defs"
}
fn def_name() -> &'static str {
"itemView"
}
fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
lexicon_doc_social_showcase_defs()
}
fn validate(
&self,
) -> ::core::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
if let Some(ref value) = self.category {
#[allow(unused_comparisons)]
if <str>::len(value.as_ref()) > 100usize {
return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
path: ::jacquard_lexicon::validation::ValidationPath::from_field(
"category",
),
max: 100usize,
actual: <str>::len(value.as_ref()),
});
}
}
if let Some(ref value) = self.description {
#[allow(unused_comparisons)]
if <str>::len(value.as_ref()) > 3000usize {
return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
path: ::jacquard_lexicon::validation::ValidationPath::from_field(
"description",
),
max: 3000usize,
actual: <str>::len(value.as_ref()),
});
}
}
if let Some(ref value) = self.external_link {
#[allow(unused_comparisons)]
if <str>::len(value.as_ref()) > 2048usize {
return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
path: ::jacquard_lexicon::validation::ValidationPath::from_field(
"external_link",
),
max: 2048usize,
actual: <str>::len(value.as_ref()),
});
}
}
{
let value = &self.title;
#[allow(unused_comparisons)]
if <str>::len(value.as_ref()) > 300usize {
return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
path: ::jacquard_lexicon::validation::ValidationPath::from_field(
"title",
),
max: 300usize,
actual: <str>::len(value.as_ref()),
});
}
}
{
let value = &self.visibility;
#[allow(unused_comparisons)]
if <str>::len(value.as_ref()) > 10usize {
return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
path: ::jacquard_lexicon::validation::ValidationPath::from_field(
"visibility",
),
max: 10usize,
actual: <str>::len(value.as_ref()),
});
}
}
Ok(())
}
}
#[jacquard_derive::lexicon]
#[derive(
serde::Serialize,
serde::Deserialize,
Debug,
Clone,
PartialEq,
Eq,
jacquard_derive::IntoStatic
)]
#[serde(rename_all = "camelCase")]
pub struct NotificationSettings<'a> {
pub comments: bool,
pub follows: bool,
pub reactions: bool,
}
pub mod notification_settings_state {
pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
#[allow(unused)]
use ::core::marker::PhantomData;
mod sealed {
pub trait Sealed {}
}
pub trait State: sealed::Sealed {
type Follows;
type Comments;
type Reactions;
}
pub struct Empty(());
impl sealed::Sealed for Empty {}
impl State for Empty {
type Follows = Unset;
type Comments = Unset;
type Reactions = Unset;
}
pub struct SetFollows<S: State = Empty>(PhantomData<fn() -> S>);
impl<S: State> sealed::Sealed for SetFollows<S> {}
impl<S: State> State for SetFollows<S> {
type Follows = Set<members::follows>;
type Comments = S::Comments;
type Reactions = S::Reactions;
}
pub struct SetComments<S: State = Empty>(PhantomData<fn() -> S>);
impl<S: State> sealed::Sealed for SetComments<S> {}
impl<S: State> State for SetComments<S> {
type Follows = S::Follows;
type Comments = Set<members::comments>;
type Reactions = S::Reactions;
}
pub struct SetReactions<S: State = Empty>(PhantomData<fn() -> S>);
impl<S: State> sealed::Sealed for SetReactions<S> {}
impl<S: State> State for SetReactions<S> {
type Follows = S::Follows;
type Comments = S::Comments;
type Reactions = Set<members::reactions>;
}
#[allow(non_camel_case_types)]
pub mod members {
pub struct follows(());
pub struct comments(());
pub struct reactions(());
}
}
pub struct NotificationSettingsBuilder<'a, S: notification_settings_state::State> {
_phantom_state: ::core::marker::PhantomData<fn() -> S>,
__unsafe_private_named: (
::core::option::Option<bool>,
::core::option::Option<bool>,
::core::option::Option<bool>,
),
_phantom: ::core::marker::PhantomData<&'a ()>,
}
impl<'a> NotificationSettings<'a> {
pub fn new() -> NotificationSettingsBuilder<'a, notification_settings_state::Empty> {
NotificationSettingsBuilder::new()
}
}
impl<'a> NotificationSettingsBuilder<'a, notification_settings_state::Empty> {
pub fn new() -> Self {
NotificationSettingsBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: (None, None, None),
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> NotificationSettingsBuilder<'a, S>
where
S: notification_settings_state::State,
S::Comments: notification_settings_state::IsUnset,
{
pub fn comments(
mut self,
value: impl Into<bool>,
) -> NotificationSettingsBuilder<'a, notification_settings_state::SetComments<S>> {
self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
NotificationSettingsBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> NotificationSettingsBuilder<'a, S>
where
S: notification_settings_state::State,
S::Follows: notification_settings_state::IsUnset,
{
pub fn follows(
mut self,
value: impl Into<bool>,
) -> NotificationSettingsBuilder<'a, notification_settings_state::SetFollows<S>> {
self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
NotificationSettingsBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> NotificationSettingsBuilder<'a, S>
where
S: notification_settings_state::State,
S::Reactions: notification_settings_state::IsUnset,
{
pub fn reactions(
mut self,
value: impl Into<bool>,
) -> NotificationSettingsBuilder<'a, notification_settings_state::SetReactions<S>> {
self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into());
NotificationSettingsBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> NotificationSettingsBuilder<'a, S>
where
S: notification_settings_state::State,
S::Follows: notification_settings_state::IsSet,
S::Comments: notification_settings_state::IsSet,
S::Reactions: notification_settings_state::IsSet,
{
pub fn build(self) -> NotificationSettings<'a> {
NotificationSettings {
comments: self.__unsafe_private_named.0.unwrap(),
follows: self.__unsafe_private_named.1.unwrap(),
reactions: self.__unsafe_private_named.2.unwrap(),
extra_data: Default::default(),
}
}
pub fn build_with_data(
self,
extra_data: std::collections::BTreeMap<
jacquard_common::deps::smol_str::SmolStr,
jacquard_common::types::value::Data<'a>,
>,
) -> NotificationSettings<'a> {
NotificationSettings {
comments: self.__unsafe_private_named.0.unwrap(),
follows: self.__unsafe_private_named.1.unwrap(),
reactions: self.__unsafe_private_named.2.unwrap(),
extra_data: Some(extra_data),
}
}
}
impl<'a> ::jacquard_lexicon::schema::LexiconSchema for NotificationSettings<'a> {
fn nsid() -> &'static str {
"social.showcase.defs"
}
fn def_name() -> &'static str {
"notificationSettings"
}
fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
lexicon_doc_social_showcase_defs()
}
fn validate(
&self,
) -> ::core::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
Ok(())
}
}
#[jacquard_derive::lexicon]
#[derive(
serde::Serialize,
serde::Deserialize,
Debug,
Clone,
PartialEq,
Eq,
jacquard_derive::IntoStatic
)]
#[serde(rename_all = "camelCase")]
pub struct PrivacySettings<'a> {
pub allow_comments: bool,
pub allow_reactions: bool,
pub indexable: bool,
}
pub mod privacy_settings_state {
pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
#[allow(unused)]
use ::core::marker::PhantomData;
mod sealed {
pub trait Sealed {}
}
pub trait State: sealed::Sealed {
type AllowReactions;
type Indexable;
type AllowComments;
}
pub struct Empty(());
impl sealed::Sealed for Empty {}
impl State for Empty {
type AllowReactions = Unset;
type Indexable = Unset;
type AllowComments = Unset;
}
pub struct SetAllowReactions<S: State = Empty>(PhantomData<fn() -> S>);
impl<S: State> sealed::Sealed for SetAllowReactions<S> {}
impl<S: State> State for SetAllowReactions<S> {
type AllowReactions = Set<members::allow_reactions>;
type Indexable = S::Indexable;
type AllowComments = S::AllowComments;
}
pub struct SetIndexable<S: State = Empty>(PhantomData<fn() -> S>);
impl<S: State> sealed::Sealed for SetIndexable<S> {}
impl<S: State> State for SetIndexable<S> {
type AllowReactions = S::AllowReactions;
type Indexable = Set<members::indexable>;
type AllowComments = S::AllowComments;
}
pub struct SetAllowComments<S: State = Empty>(PhantomData<fn() -> S>);
impl<S: State> sealed::Sealed for SetAllowComments<S> {}
impl<S: State> State for SetAllowComments<S> {
type AllowReactions = S::AllowReactions;
type Indexable = S::Indexable;
type AllowComments = Set<members::allow_comments>;
}
#[allow(non_camel_case_types)]
pub mod members {
pub struct allow_reactions(());
pub struct indexable(());
pub struct allow_comments(());
}
}
pub struct PrivacySettingsBuilder<'a, S: privacy_settings_state::State> {
_phantom_state: ::core::marker::PhantomData<fn() -> S>,
__unsafe_private_named: (
::core::option::Option<bool>,
::core::option::Option<bool>,
::core::option::Option<bool>,
),
_phantom: ::core::marker::PhantomData<&'a ()>,
}
impl<'a> PrivacySettings<'a> {
pub fn new() -> PrivacySettingsBuilder<'a, privacy_settings_state::Empty> {
PrivacySettingsBuilder::new()
}
}
impl<'a> PrivacySettingsBuilder<'a, privacy_settings_state::Empty> {
pub fn new() -> Self {
PrivacySettingsBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: (None, None, None),
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> PrivacySettingsBuilder<'a, S>
where
S: privacy_settings_state::State,
S::AllowComments: privacy_settings_state::IsUnset,
{
pub fn allow_comments(
mut self,
value: impl Into<bool>,
) -> PrivacySettingsBuilder<'a, privacy_settings_state::SetAllowComments<S>> {
self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
PrivacySettingsBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> PrivacySettingsBuilder<'a, S>
where
S: privacy_settings_state::State,
S::AllowReactions: privacy_settings_state::IsUnset,
{
pub fn allow_reactions(
mut self,
value: impl Into<bool>,
) -> PrivacySettingsBuilder<'a, privacy_settings_state::SetAllowReactions<S>> {
self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
PrivacySettingsBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> PrivacySettingsBuilder<'a, S>
where
S: privacy_settings_state::State,
S::Indexable: privacy_settings_state::IsUnset,
{
pub fn indexable(
mut self,
value: impl Into<bool>,
) -> PrivacySettingsBuilder<'a, privacy_settings_state::SetIndexable<S>> {
self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into());
PrivacySettingsBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> PrivacySettingsBuilder<'a, S>
where
S: privacy_settings_state::State,
S::AllowReactions: privacy_settings_state::IsSet,
S::Indexable: privacy_settings_state::IsSet,
S::AllowComments: privacy_settings_state::IsSet,
{
pub fn build(self) -> PrivacySettings<'a> {
PrivacySettings {
allow_comments: self.__unsafe_private_named.0.unwrap(),
allow_reactions: self.__unsafe_private_named.1.unwrap(),
indexable: self.__unsafe_private_named.2.unwrap(),
extra_data: Default::default(),
}
}
pub fn build_with_data(
self,
extra_data: std::collections::BTreeMap<
jacquard_common::deps::smol_str::SmolStr,
jacquard_common::types::value::Data<'a>,
>,
) -> PrivacySettings<'a> {
PrivacySettings {
allow_comments: self.__unsafe_private_named.0.unwrap(),
allow_reactions: self.__unsafe_private_named.1.unwrap(),
indexable: self.__unsafe_private_named.2.unwrap(),
extra_data: Some(extra_data),
}
}
}
impl<'a> ::jacquard_lexicon::schema::LexiconSchema for PrivacySettings<'a> {
fn nsid() -> &'static str {
"social.showcase.defs"
}
fn def_name() -> &'static str {
"privacySettings"
}
fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
lexicon_doc_social_showcase_defs()
}
fn validate(
&self,
) -> ::core::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
Ok(())
}
}
#[jacquard_derive::lexicon]
#[derive(
serde::Serialize,
serde::Deserialize,
Debug,
Clone,
PartialEq,
Eq,
jacquard_derive::IntoStatic,
Default
)]
#[serde(rename_all = "camelCase")]
pub struct ProfileView<'a> {
#[serde(skip_serializing_if = "std::option::Option::is_none")]
#[serde(borrow)]
pub avatar: std::option::Option<jacquard_common::types::blob::BlobRef<'a>>,
#[serde(skip_serializing_if = "std::option::Option::is_none")]
#[serde(borrow)]
pub banner: std::option::Option<jacquard_common::types::blob::BlobRef<'a>>,
#[serde(borrow)]
pub did: jacquard_common::CowStr<'a>,
#[serde(skip_serializing_if = "std::option::Option::is_none")]
#[serde(borrow)]
pub display_name: std::option::Option<jacquard_common::CowStr<'a>>,
#[serde(borrow)]
pub handle: jacquard_common::CowStr<'a>,
#[serde(skip_serializing_if = "std::option::Option::is_none")]
#[serde(borrow)]
pub tags: std::option::Option<Vec<jacquard_common::CowStr<'a>>>,
}
impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ProfileView<'a> {
fn nsid() -> &'static str {
"social.showcase.defs"
}
fn def_name() -> &'static str {
"profileView"
}
fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
lexicon_doc_social_showcase_defs()
}
fn validate(
&self,
) -> ::core::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
{
let value = &self.did;
#[allow(unused_comparisons)]
if <str>::len(value.as_ref()) > 2048usize {
return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
path: ::jacquard_lexicon::validation::ValidationPath::from_field(
"did",
),
max: 2048usize,
actual: <str>::len(value.as_ref()),
});
}
}
if let Some(ref value) = self.display_name {
#[allow(unused_comparisons)]
if <str>::len(value.as_ref()) > 64usize {
return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
path: ::jacquard_lexicon::validation::ValidationPath::from_field(
"display_name",
),
max: 64usize,
actual: <str>::len(value.as_ref()),
});
}
}
{
let value = &self.handle;
#[allow(unused_comparisons)]
if <str>::len(value.as_ref()) > 253usize {
return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
path: ::jacquard_lexicon::validation::ValidationPath::from_field(
"handle",
),
max: 253usize,
actual: <str>::len(value.as_ref()),
});
}
}
Ok(())
}
}
#[jacquard_derive::lexicon]
#[derive(
serde::Serialize,
serde::Deserialize,
Debug,
Clone,
PartialEq,
Eq,
jacquard_derive::IntoStatic
)]
#[serde(rename_all = "camelCase")]
pub struct ReactionSubject<'a> {
#[serde(borrow)]
pub cid: jacquard_common::types::string::Cid<'a>,
#[serde(borrow)]
pub uri: jacquard_common::types::string::AtUri<'a>,
}
pub mod reaction_subject_state {
pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
#[allow(unused)]
use ::core::marker::PhantomData;
mod sealed {
pub trait Sealed {}
}
pub trait State: sealed::Sealed {
type Cid;
type Uri;
}
pub struct Empty(());
impl sealed::Sealed for Empty {}
impl State for Empty {
type Cid = Unset;
type Uri = Unset;
}
pub struct SetCid<S: State = Empty>(PhantomData<fn() -> S>);
impl<S: State> sealed::Sealed for SetCid<S> {}
impl<S: State> State for SetCid<S> {
type Cid = Set<members::cid>;
type Uri = S::Uri;
}
pub struct SetUri<S: State = Empty>(PhantomData<fn() -> S>);
impl<S: State> sealed::Sealed for SetUri<S> {}
impl<S: State> State for SetUri<S> {
type Cid = S::Cid;
type Uri = Set<members::uri>;
}
#[allow(non_camel_case_types)]
pub mod members {
pub struct cid(());
pub struct uri(());
}
}
pub struct ReactionSubjectBuilder<'a, S: reaction_subject_state::State> {
_phantom_state: ::core::marker::PhantomData<fn() -> S>,
__unsafe_private_named: (
::core::option::Option<jacquard_common::types::string::Cid<'a>>,
::core::option::Option<jacquard_common::types::string::AtUri<'a>>,
),
_phantom: ::core::marker::PhantomData<&'a ()>,
}
impl<'a> ReactionSubject<'a> {
pub fn new() -> ReactionSubjectBuilder<'a, reaction_subject_state::Empty> {
ReactionSubjectBuilder::new()
}
}
impl<'a> ReactionSubjectBuilder<'a, reaction_subject_state::Empty> {
pub fn new() -> Self {
ReactionSubjectBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: (None, None),
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> ReactionSubjectBuilder<'a, S>
where
S: reaction_subject_state::State,
S::Cid: reaction_subject_state::IsUnset,
{
pub fn cid(
mut self,
value: impl Into<jacquard_common::types::string::Cid<'a>>,
) -> ReactionSubjectBuilder<'a, reaction_subject_state::SetCid<S>> {
self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
ReactionSubjectBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> ReactionSubjectBuilder<'a, S>
where
S: reaction_subject_state::State,
S::Uri: reaction_subject_state::IsUnset,
{
pub fn uri(
mut self,
value: impl Into<jacquard_common::types::string::AtUri<'a>>,
) -> ReactionSubjectBuilder<'a, reaction_subject_state::SetUri<S>> {
self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
ReactionSubjectBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> ReactionSubjectBuilder<'a, S>
where
S: reaction_subject_state::State,
S::Cid: reaction_subject_state::IsSet,
S::Uri: reaction_subject_state::IsSet,
{
pub fn build(self) -> ReactionSubject<'a> {
ReactionSubject {
cid: self.__unsafe_private_named.0.unwrap(),
uri: self.__unsafe_private_named.1.unwrap(),
extra_data: Default::default(),
}
}
pub fn build_with_data(
self,
extra_data: std::collections::BTreeMap<
jacquard_common::deps::smol_str::SmolStr,
jacquard_common::types::value::Data<'a>,
>,
) -> ReactionSubject<'a> {
ReactionSubject {
cid: self.__unsafe_private_named.0.unwrap(),
uri: self.__unsafe_private_named.1.unwrap(),
extra_data: Some(extra_data),
}
}
}
impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ReactionSubject<'a> {
fn nsid() -> &'static str {
"social.showcase.defs"
}
fn def_name() -> &'static str {
"reactionSubject"
}
fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
lexicon_doc_social_showcase_defs()
}
fn validate(
&self,
) -> ::core::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
Ok(())
}
}
#[jacquard_derive::lexicon]
#[derive(
serde::Serialize,
serde::Deserialize,
Debug,
Clone,
PartialEq,
Eq,
jacquard_derive::IntoStatic
)]
#[serde(rename_all = "camelCase")]
pub struct ReactionView<'a> {
#[serde(borrow)]
pub actor: crate::social_showcase::ProfileView<'a>,
pub created_at: jacquard_common::types::string::Datetime,
#[serde(borrow)]
pub subject: crate::social_showcase::ReactionSubject<'a>,
#[serde(borrow)]
pub r#type: jacquard_common::CowStr<'a>,
#[serde(borrow)]
pub uri: jacquard_common::types::string::AtUri<'a>,
}
pub mod reaction_view_state {
pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
#[allow(unused)]
use ::core::marker::PhantomData;
mod sealed {
pub trait Sealed {}
}
pub trait State: sealed::Sealed {
type Uri;
type Type;
type Actor;
type Subject;
type CreatedAt;
}
pub struct Empty(());
impl sealed::Sealed for Empty {}
impl State for Empty {
type Uri = Unset;
type Type = Unset;
type Actor = Unset;
type Subject = Unset;
type CreatedAt = Unset;
}
pub struct SetUri<S: State = Empty>(PhantomData<fn() -> S>);
impl<S: State> sealed::Sealed for SetUri<S> {}
impl<S: State> State for SetUri<S> {
type Uri = Set<members::uri>;
type Type = S::Type;
type Actor = S::Actor;
type Subject = S::Subject;
type CreatedAt = S::CreatedAt;
}
pub struct SetType<S: State = Empty>(PhantomData<fn() -> S>);
impl<S: State> sealed::Sealed for SetType<S> {}
impl<S: State> State for SetType<S> {
type Uri = S::Uri;
type Type = Set<members::r#type>;
type Actor = S::Actor;
type Subject = S::Subject;
type CreatedAt = S::CreatedAt;
}
pub struct SetActor<S: State = Empty>(PhantomData<fn() -> S>);
impl<S: State> sealed::Sealed for SetActor<S> {}
impl<S: State> State for SetActor<S> {
type Uri = S::Uri;
type Type = S::Type;
type Actor = Set<members::actor>;
type Subject = S::Subject;
type CreatedAt = S::CreatedAt;
}
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 Uri = S::Uri;
type Type = S::Type;
type Actor = S::Actor;
type Subject = Set<members::subject>;
type CreatedAt = S::CreatedAt;
}
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 Uri = S::Uri;
type Type = S::Type;
type Actor = S::Actor;
type Subject = S::Subject;
type CreatedAt = Set<members::created_at>;
}
#[allow(non_camel_case_types)]
pub mod members {
pub struct uri(());
pub struct r#type(());
pub struct actor(());
pub struct subject(());
pub struct created_at(());
}
}
pub struct ReactionViewBuilder<'a, S: reaction_view_state::State> {
_phantom_state: ::core::marker::PhantomData<fn() -> S>,
__unsafe_private_named: (
::core::option::Option<crate::social_showcase::ProfileView<'a>>,
::core::option::Option<jacquard_common::types::string::Datetime>,
::core::option::Option<crate::social_showcase::ReactionSubject<'a>>,
::core::option::Option<jacquard_common::CowStr<'a>>,
::core::option::Option<jacquard_common::types::string::AtUri<'a>>,
),
_phantom: ::core::marker::PhantomData<&'a ()>,
}
impl<'a> ReactionView<'a> {
pub fn new() -> ReactionViewBuilder<'a, reaction_view_state::Empty> {
ReactionViewBuilder::new()
}
}
impl<'a> ReactionViewBuilder<'a, reaction_view_state::Empty> {
pub fn new() -> Self {
ReactionViewBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: (None, None, None, None, None),
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> ReactionViewBuilder<'a, S>
where
S: reaction_view_state::State,
S::Actor: reaction_view_state::IsUnset,
{
pub fn actor(
mut self,
value: impl Into<crate::social_showcase::ProfileView<'a>>,
) -> ReactionViewBuilder<'a, reaction_view_state::SetActor<S>> {
self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
ReactionViewBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> ReactionViewBuilder<'a, S>
where
S: reaction_view_state::State,
S::CreatedAt: reaction_view_state::IsUnset,
{
pub fn created_at(
mut self,
value: impl Into<jacquard_common::types::string::Datetime>,
) -> ReactionViewBuilder<'a, reaction_view_state::SetCreatedAt<S>> {
self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
ReactionViewBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> ReactionViewBuilder<'a, S>
where
S: reaction_view_state::State,
S::Subject: reaction_view_state::IsUnset,
{
pub fn subject(
mut self,
value: impl Into<crate::social_showcase::ReactionSubject<'a>>,
) -> ReactionViewBuilder<'a, reaction_view_state::SetSubject<S>> {
self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into());
ReactionViewBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> ReactionViewBuilder<'a, S>
where
S: reaction_view_state::State,
S::Type: reaction_view_state::IsUnset,
{
pub fn r#type(
mut self,
value: impl Into<jacquard_common::CowStr<'a>>,
) -> ReactionViewBuilder<'a, reaction_view_state::SetType<S>> {
self.__unsafe_private_named.3 = ::core::option::Option::Some(value.into());
ReactionViewBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> ReactionViewBuilder<'a, S>
where
S: reaction_view_state::State,
S::Uri: reaction_view_state::IsUnset,
{
pub fn uri(
mut self,
value: impl Into<jacquard_common::types::string::AtUri<'a>>,
) -> ReactionViewBuilder<'a, reaction_view_state::SetUri<S>> {
self.__unsafe_private_named.4 = ::core::option::Option::Some(value.into());
ReactionViewBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> ReactionViewBuilder<'a, S>
where
S: reaction_view_state::State,
S::Uri: reaction_view_state::IsSet,
S::Type: reaction_view_state::IsSet,
S::Actor: reaction_view_state::IsSet,
S::Subject: reaction_view_state::IsSet,
S::CreatedAt: reaction_view_state::IsSet,
{
pub fn build(self) -> ReactionView<'a> {
ReactionView {
actor: self.__unsafe_private_named.0.unwrap(),
created_at: self.__unsafe_private_named.1.unwrap(),
subject: self.__unsafe_private_named.2.unwrap(),
r#type: self.__unsafe_private_named.3.unwrap(),
uri: self.__unsafe_private_named.4.unwrap(),
extra_data: Default::default(),
}
}
pub fn build_with_data(
self,
extra_data: std::collections::BTreeMap<
jacquard_common::deps::smol_str::SmolStr,
jacquard_common::types::value::Data<'a>,
>,
) -> ReactionView<'a> {
ReactionView {
actor: self.__unsafe_private_named.0.unwrap(),
created_at: self.__unsafe_private_named.1.unwrap(),
subject: self.__unsafe_private_named.2.unwrap(),
r#type: self.__unsafe_private_named.3.unwrap(),
uri: self.__unsafe_private_named.4.unwrap(),
extra_data: Some(extra_data),
}
}
}
impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ReactionView<'a> {
fn nsid() -> &'static str {
"social.showcase.defs"
}
fn def_name() -> &'static str {
"reactionView"
}
fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
lexicon_doc_social_showcase_defs()
}
fn validate(
&self,
) -> ::core::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
{
let value = &self.r#type;
#[allow(unused_comparisons)]
if <str>::len(value.as_ref()) > 100usize {
return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
path: ::jacquard_lexicon::validation::ValidationPath::from_field(
"type",
),
max: 100usize,
actual: <str>::len(value.as_ref()),
});
}
}
Ok(())
}
}
#[jacquard_derive::lexicon]
#[derive(
serde::Serialize,
serde::Deserialize,
Debug,
Clone,
PartialEq,
Eq,
jacquard_derive::IntoStatic
)]
#[serde(rename_all = "camelCase")]
pub struct ShowcaseItem<'a> {
pub added_at: jacquard_common::types::string::Datetime,
pub order: i64,
#[serde(borrow)]
pub uri: jacquard_common::types::string::AtUri<'a>,
}
pub mod showcase_item_state {
pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
#[allow(unused)]
use ::core::marker::PhantomData;
mod sealed {
pub trait Sealed {}
}
pub trait State: sealed::Sealed {
type Order;
type Uri;
type AddedAt;
}
pub struct Empty(());
impl sealed::Sealed for Empty {}
impl State for Empty {
type Order = Unset;
type Uri = Unset;
type AddedAt = Unset;
}
pub struct SetOrder<S: State = Empty>(PhantomData<fn() -> S>);
impl<S: State> sealed::Sealed for SetOrder<S> {}
impl<S: State> State for SetOrder<S> {
type Order = Set<members::order>;
type Uri = S::Uri;
type AddedAt = S::AddedAt;
}
pub struct SetUri<S: State = Empty>(PhantomData<fn() -> S>);
impl<S: State> sealed::Sealed for SetUri<S> {}
impl<S: State> State for SetUri<S> {
type Order = S::Order;
type Uri = Set<members::uri>;
type AddedAt = S::AddedAt;
}
pub struct SetAddedAt<S: State = Empty>(PhantomData<fn() -> S>);
impl<S: State> sealed::Sealed for SetAddedAt<S> {}
impl<S: State> State for SetAddedAt<S> {
type Order = S::Order;
type Uri = S::Uri;
type AddedAt = Set<members::added_at>;
}
#[allow(non_camel_case_types)]
pub mod members {
pub struct order(());
pub struct uri(());
pub struct added_at(());
}
}
pub struct ShowcaseItemBuilder<'a, S: showcase_item_state::State> {
_phantom_state: ::core::marker::PhantomData<fn() -> S>,
__unsafe_private_named: (
::core::option::Option<jacquard_common::types::string::Datetime>,
::core::option::Option<i64>,
::core::option::Option<jacquard_common::types::string::AtUri<'a>>,
),
_phantom: ::core::marker::PhantomData<&'a ()>,
}
impl<'a> ShowcaseItem<'a> {
pub fn new() -> ShowcaseItemBuilder<'a, showcase_item_state::Empty> {
ShowcaseItemBuilder::new()
}
}
impl<'a> ShowcaseItemBuilder<'a, showcase_item_state::Empty> {
pub fn new() -> Self {
ShowcaseItemBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: (None, None, None),
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> ShowcaseItemBuilder<'a, S>
where
S: showcase_item_state::State,
S::AddedAt: showcase_item_state::IsUnset,
{
pub fn added_at(
mut self,
value: impl Into<jacquard_common::types::string::Datetime>,
) -> ShowcaseItemBuilder<'a, showcase_item_state::SetAddedAt<S>> {
self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
ShowcaseItemBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> ShowcaseItemBuilder<'a, S>
where
S: showcase_item_state::State,
S::Order: showcase_item_state::IsUnset,
{
pub fn order(
mut self,
value: impl Into<i64>,
) -> ShowcaseItemBuilder<'a, showcase_item_state::SetOrder<S>> {
self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
ShowcaseItemBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> ShowcaseItemBuilder<'a, S>
where
S: showcase_item_state::State,
S::Uri: showcase_item_state::IsUnset,
{
pub fn uri(
mut self,
value: impl Into<jacquard_common::types::string::AtUri<'a>>,
) -> ShowcaseItemBuilder<'a, showcase_item_state::SetUri<S>> {
self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into());
ShowcaseItemBuilder {
_phantom_state: ::core::marker::PhantomData,
__unsafe_private_named: self.__unsafe_private_named,
_phantom: ::core::marker::PhantomData,
}
}
}
impl<'a, S> ShowcaseItemBuilder<'a, S>
where
S: showcase_item_state::State,
S::Order: showcase_item_state::IsSet,
S::Uri: showcase_item_state::IsSet,
S::AddedAt: showcase_item_state::IsSet,
{
pub fn build(self) -> ShowcaseItem<'a> {
ShowcaseItem {
added_at: self.__unsafe_private_named.0.unwrap(),
order: self.__unsafe_private_named.1.unwrap(),
uri: self.__unsafe_private_named.2.unwrap(),
extra_data: Default::default(),
}
}
pub fn build_with_data(
self,
extra_data: std::collections::BTreeMap<
jacquard_common::deps::smol_str::SmolStr,
jacquard_common::types::value::Data<'a>,
>,
) -> ShowcaseItem<'a> {
ShowcaseItem {
added_at: self.__unsafe_private_named.0.unwrap(),
order: self.__unsafe_private_named.1.unwrap(),
uri: self.__unsafe_private_named.2.unwrap(),
extra_data: Some(extra_data),
}
}
}
impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ShowcaseItem<'a> {
fn nsid() -> &'static str {
"social.showcase.defs"
}
fn def_name() -> &'static str {
"showcaseItem"
}
fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
lexicon_doc_social_showcase_defs()
}
fn validate(
&self,
) -> ::core::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
Ok(())
}
}
#[jacquard_derive::lexicon]
#[derive(
serde::Serialize,
serde::Deserialize,
Debug,
Clone,
PartialEq,
Eq,
jacquard_derive::IntoStatic,
Default
)]
#[serde(rename_all = "camelCase")]
pub struct VisibilitySettings<'a> {
#[serde(borrow)]
pub default_collection_visibility: VisibilitySettingsDefaultCollectionVisibility<'a>,
#[serde(borrow)]
pub default_item_visibility: VisibilitySettingsDefaultItemVisibility<'a>,
#[serde(borrow)]
pub profile_visibility: VisibilitySettingsProfileVisibility<'a>,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum VisibilitySettingsDefaultCollectionVisibility<'a> {
Public,
Private,
Other(jacquard_common::CowStr<'a>),
}
impl<'a> VisibilitySettingsDefaultCollectionVisibility<'a> {
pub fn as_str(&self) -> &str {
match self {
Self::Public => "public",
Self::Private => "private",
Self::Other(s) => s.as_ref(),
}
}
}
impl<'a> From<&'a str> for VisibilitySettingsDefaultCollectionVisibility<'a> {
fn from(s: &'a str) -> Self {
match s {
"public" => Self::Public,
"private" => Self::Private,
_ => Self::Other(jacquard_common::CowStr::from(s)),
}
}
}
impl<'a> From<String> for VisibilitySettingsDefaultCollectionVisibility<'a> {
fn from(s: String) -> Self {
match s.as_str() {
"public" => Self::Public,
"private" => Self::Private,
_ => Self::Other(jacquard_common::CowStr::from(s)),
}
}
}
impl<'a> core::fmt::Display for VisibilitySettingsDefaultCollectionVisibility<'a> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "{}", self.as_str())
}
}
impl<'a> AsRef<str> for VisibilitySettingsDefaultCollectionVisibility<'a> {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl<'a> serde::Serialize for VisibilitySettingsDefaultCollectionVisibility<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serializer.serialize_str(self.as_str())
}
}
impl<'de, 'a> serde::Deserialize<'de>
for VisibilitySettingsDefaultCollectionVisibility<'a>
where
'de: 'a,
{
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let s = <&'de str>::deserialize(deserializer)?;
Ok(Self::from(s))
}
}
impl<'a> Default for VisibilitySettingsDefaultCollectionVisibility<'a> {
fn default() -> Self {
Self::Other(Default::default())
}
}
impl jacquard_common::IntoStatic for VisibilitySettingsDefaultCollectionVisibility<'_> {
type Output = VisibilitySettingsDefaultCollectionVisibility<'static>;
fn into_static(self) -> Self::Output {
match self {
VisibilitySettingsDefaultCollectionVisibility::Public => {
VisibilitySettingsDefaultCollectionVisibility::Public
}
VisibilitySettingsDefaultCollectionVisibility::Private => {
VisibilitySettingsDefaultCollectionVisibility::Private
}
VisibilitySettingsDefaultCollectionVisibility::Other(v) => {
VisibilitySettingsDefaultCollectionVisibility::Other(v.into_static())
}
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum VisibilitySettingsDefaultItemVisibility<'a> {
Public,
Unlisted,
Private,
Other(jacquard_common::CowStr<'a>),
}
impl<'a> VisibilitySettingsDefaultItemVisibility<'a> {
pub fn as_str(&self) -> &str {
match self {
Self::Public => "public",
Self::Unlisted => "unlisted",
Self::Private => "private",
Self::Other(s) => s.as_ref(),
}
}
}
impl<'a> From<&'a str> for VisibilitySettingsDefaultItemVisibility<'a> {
fn from(s: &'a str) -> Self {
match s {
"public" => Self::Public,
"unlisted" => Self::Unlisted,
"private" => Self::Private,
_ => Self::Other(jacquard_common::CowStr::from(s)),
}
}
}
impl<'a> From<String> for VisibilitySettingsDefaultItemVisibility<'a> {
fn from(s: String) -> Self {
match s.as_str() {
"public" => Self::Public,
"unlisted" => Self::Unlisted,
"private" => Self::Private,
_ => Self::Other(jacquard_common::CowStr::from(s)),
}
}
}
impl<'a> core::fmt::Display for VisibilitySettingsDefaultItemVisibility<'a> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "{}", self.as_str())
}
}
impl<'a> AsRef<str> for VisibilitySettingsDefaultItemVisibility<'a> {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl<'a> serde::Serialize for VisibilitySettingsDefaultItemVisibility<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serializer.serialize_str(self.as_str())
}
}
impl<'de, 'a> serde::Deserialize<'de> for VisibilitySettingsDefaultItemVisibility<'a>
where
'de: 'a,
{
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let s = <&'de str>::deserialize(deserializer)?;
Ok(Self::from(s))
}
}
impl<'a> Default for VisibilitySettingsDefaultItemVisibility<'a> {
fn default() -> Self {
Self::Other(Default::default())
}
}
impl jacquard_common::IntoStatic for VisibilitySettingsDefaultItemVisibility<'_> {
type Output = VisibilitySettingsDefaultItemVisibility<'static>;
fn into_static(self) -> Self::Output {
match self {
VisibilitySettingsDefaultItemVisibility::Public => {
VisibilitySettingsDefaultItemVisibility::Public
}
VisibilitySettingsDefaultItemVisibility::Unlisted => {
VisibilitySettingsDefaultItemVisibility::Unlisted
}
VisibilitySettingsDefaultItemVisibility::Private => {
VisibilitySettingsDefaultItemVisibility::Private
}
VisibilitySettingsDefaultItemVisibility::Other(v) => {
VisibilitySettingsDefaultItemVisibility::Other(v.into_static())
}
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum VisibilitySettingsProfileVisibility<'a> {
Public,
Unlisted,
Private,
Other(jacquard_common::CowStr<'a>),
}
impl<'a> VisibilitySettingsProfileVisibility<'a> {
pub fn as_str(&self) -> &str {
match self {
Self::Public => "public",
Self::Unlisted => "unlisted",
Self::Private => "private",
Self::Other(s) => s.as_ref(),
}
}
}
impl<'a> From<&'a str> for VisibilitySettingsProfileVisibility<'a> {
fn from(s: &'a str) -> Self {
match s {
"public" => Self::Public,
"unlisted" => Self::Unlisted,
"private" => Self::Private,
_ => Self::Other(jacquard_common::CowStr::from(s)),
}
}
}
impl<'a> From<String> for VisibilitySettingsProfileVisibility<'a> {
fn from(s: String) -> Self {
match s.as_str() {
"public" => Self::Public,
"unlisted" => Self::Unlisted,
"private" => Self::Private,
_ => Self::Other(jacquard_common::CowStr::from(s)),
}
}
}
impl<'a> core::fmt::Display for VisibilitySettingsProfileVisibility<'a> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "{}", self.as_str())
}
}
impl<'a> AsRef<str> for VisibilitySettingsProfileVisibility<'a> {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl<'a> serde::Serialize for VisibilitySettingsProfileVisibility<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serializer.serialize_str(self.as_str())
}
}
impl<'de, 'a> serde::Deserialize<'de> for VisibilitySettingsProfileVisibility<'a>
where
'de: 'a,
{
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let s = <&'de str>::deserialize(deserializer)?;
Ok(Self::from(s))
}
}
impl<'a> Default for VisibilitySettingsProfileVisibility<'a> {
fn default() -> Self {
Self::Other(Default::default())
}
}
impl jacquard_common::IntoStatic for VisibilitySettingsProfileVisibility<'_> {
type Output = VisibilitySettingsProfileVisibility<'static>;
fn into_static(self) -> Self::Output {
match self {
VisibilitySettingsProfileVisibility::Public => {
VisibilitySettingsProfileVisibility::Public
}
VisibilitySettingsProfileVisibility::Unlisted => {
VisibilitySettingsProfileVisibility::Unlisted
}
VisibilitySettingsProfileVisibility::Private => {
VisibilitySettingsProfileVisibility::Private
}
VisibilitySettingsProfileVisibility::Other(v) => {
VisibilitySettingsProfileVisibility::Other(v.into_static())
}
}
}
}
impl<'a> ::jacquard_lexicon::schema::LexiconSchema for VisibilitySettings<'a> {
fn nsid() -> &'static str {
"social.showcase.defs"
}
fn def_name() -> &'static str {
"visibilitySettings"
}
fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
lexicon_doc_social_showcase_defs()
}
fn validate(
&self,
) -> ::core::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
{
let value = &self.default_collection_visibility;
#[allow(unused_comparisons)]
if <str>::len(value.as_ref()) > 10usize {
return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
path: ::jacquard_lexicon::validation::ValidationPath::from_field(
"default_collection_visibility",
),
max: 10usize,
actual: <str>::len(value.as_ref()),
});
}
}
{
let value = &self.default_item_visibility;
#[allow(unused_comparisons)]
if <str>::len(value.as_ref()) > 10usize {
return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
path: ::jacquard_lexicon::validation::ValidationPath::from_field(
"default_item_visibility",
),
max: 10usize,
actual: <str>::len(value.as_ref()),
});
}
}
{
let value = &self.profile_visibility;
#[allow(unused_comparisons)]
if <str>::len(value.as_ref()) > 10usize {
return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
path: ::jacquard_lexicon::validation::ValidationPath::from_field(
"profile_visibility",
),
max: 10usize,
actual: <str>::len(value.as_ref()),
});
}
}
Ok(())
}
}