// @generated by jacquard-lexicon. DO NOT EDIT.
//
// Lexicon: net.anisota.settings
//
// This file was automatically generated from Lexicon schemas.
// Any manual changes will be overwritten on the next regeneration.
#[allow(unused_imports)]
use alloc::collections::BTreeMap;
#[allow(unused_imports)]
use core::marker::PhantomData;
use jacquard_common::{BosStr, CowStr, DefaultStr, FromStaticStr};
#[allow(unused_imports)]
use jacquard_common::deps::codegen::unicode_segmentation::UnicodeSegmentation;
use jacquard_common::deps::smol_str::SmolStr;
use jacquard_common::types::collection::{Collection, RecordError};
use jacquard_common::types::string::{AtUri, Cid, Datetime};
use jacquard_common::types::uri::{RecordUri, UriError};
use jacquard_common::types::value::Data;
use jacquard_common::xrpc::XrpcResp;
use jacquard_derive::{IntoStatic, lexicon};
use jacquard_lexicon::lexicon::LexiconDoc;
use jacquard_lexicon::schema::LexiconSchema;
#[allow(unused_imports)]
use jacquard_lexicon::validation::{ConstraintError, ValidationPath};
use serde::{Deserialize, Serialize};
/// User settings for the Anisota app, synced across devices via ATProto. The collection holds one record per category, keyed by category name: 'appearance', 'behavior', 'notifications', 'chat', 'moderation', 'controls', 'observatory', 'keyboard', 'atmosphere', 'posting'. A special 'index' rkey holds a map of category names to their latest updatedAt timestamp so clients can fetch only categories whose state has drifted. The legacy 'settings' rkey is the deprecated v27 monolithic record; clients run a one-time migration that splits it into the per-category records (atomically via com.atproto.repo.applyWrites) and deletes it. Each category's full shape is defined and validated client-side via scripts/validate-settings-lexicons.js — this lexicon only enforces the universal metadata fields so new per-category fields can ship without a lexicon migration.
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(
rename_all = "camelCase",
rename = "net.anisota.settings",
tag = "$type",
bound(deserialize = "S: Deserialize<'de> + BosStr")
)]
pub struct Settings<S: BosStr = DefaultStr> {
///When this category record was first created
pub created_at: Datetime,
///When this category record was last modified
pub updated_at: Datetime,
///Settings schema version
pub version: i64,
#[serde(flatten, default, skip_serializing_if = "Option::is_none")]
pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,
}
/// Typed wrapper for GetRecord response with this collection's record type.
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase")]
pub struct SettingsGetRecordOutput<S: BosStr = DefaultStr> {
#[serde(skip_serializing_if = "Option::is_none")]
pub cid: Option<Cid<S>>,
pub uri: AtUri<S>,
pub value: Settings<S>,
}
impl<S: BosStr> Settings<S> {
pub fn uri(uri: S) -> Result<RecordUri<S, SettingsRecord>, UriError> {
RecordUri::try_from_uri(AtUri::new(uri)?)
}
}
/// Marker type for deserializing records from this collection.
#[derive(Debug, Serialize, Deserialize)]
pub struct SettingsRecord;
impl XrpcResp for SettingsRecord {
const NSID: &'static str = "net.anisota.settings";
const ENCODING: &'static str = "application/json";
type Output<S: BosStr> = SettingsGetRecordOutput<S>;
type Err = RecordError;
}
impl<S: BosStr> From<SettingsGetRecordOutput<S>> for Settings<S> {
fn from(output: SettingsGetRecordOutput<S>) -> Self {
output.value
}
}
impl<S: BosStr> Collection for Settings<S> {
const NSID: &'static str = "net.anisota.settings";
type Record = SettingsRecord;
}
impl Collection for SettingsRecord {
const NSID: &'static str = "net.anisota.settings";
type Record = SettingsRecord;
}
impl<S: BosStr> LexiconSchema for Settings<S> {
fn nsid() -> &'static str {
"net.anisota.settings"
}
fn def_name() -> &'static str {
"main"
}
fn lexicon_doc() -> LexiconDoc<'static> {
lexicon_doc_net_anisota_settings()
}
fn validate(&self) -> Result<(), ConstraintError> {
{
let value = &self.version;
if *value < 1i64 {
return Err(ConstraintError::Minimum {
path: ValidationPath::from_field("version"),
min: 1i64,
actual: *value,
});
}
}
Ok(())
}
}
pub mod settings_state {
pub use crate::builder_types::{IsSet, IsUnset, Set, Unset};
#[allow(unused)]
use ::core::marker::PhantomData;
mod sealed {
pub trait Sealed {}
}
/// State trait tracking which required fields have been set
pub trait State: sealed::Sealed {
type CreatedAt;
type UpdatedAt;
type Version;
}
/// Empty state - all required fields are unset
pub struct Empty(());
impl sealed::Sealed for Empty {}
impl State for Empty {
type CreatedAt = Unset;
type UpdatedAt = Unset;
type Version = Unset;
}
///State transition - sets the `created_at` field to Set
pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
impl<St: State> State for SetCreatedAt<St> {
type CreatedAt = Set<members::created_at>;
type UpdatedAt = St::UpdatedAt;
type Version = St::Version;
}
///State transition - sets the `updated_at` field to Set
pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
impl<St: State> State for SetUpdatedAt<St> {
type CreatedAt = St::CreatedAt;
type UpdatedAt = Set<members::updated_at>;
type Version = St::Version;
}
///State transition - sets the `version` field to Set
pub struct SetVersion<St: State = Empty>(PhantomData<fn() -> St>);
impl<St: State> sealed::Sealed for SetVersion<St> {}
impl<St: State> State for SetVersion<St> {
type CreatedAt = St::CreatedAt;
type UpdatedAt = St::UpdatedAt;
type Version = Set<members::version>;
}
/// Marker types for field names
#[allow(non_camel_case_types)]
pub mod members {
///Marker type for the `created_at` field
pub struct created_at(());
///Marker type for the `updated_at` field
pub struct updated_at(());
///Marker type for the `version` field
pub struct version(());
}
}
/// Builder for constructing an instance of this type.
pub struct SettingsBuilder<St: settings_state::State, S: BosStr = DefaultStr> {
_state: PhantomData<fn() -> St>,
_fields: (Option<Datetime>, Option<Datetime>, Option<i64>),
_type: PhantomData<fn() -> S>,
}
impl Settings<DefaultStr> {
/// Create a new builder for this type, using the default string type (DefaultStr = SmolStr) if needed
pub fn new() -> SettingsBuilder<settings_state::Empty, DefaultStr> {
SettingsBuilder::new()
}
}
impl<S: BosStr> Settings<S> {
/// Create a new builder for this type
pub fn builder() -> SettingsBuilder<settings_state::Empty, S> {
SettingsBuilder::builder()
}
}
impl SettingsBuilder<settings_state::Empty, DefaultStr> {
/// Create a new builder with all fields unset, using the default string type, if needed
pub fn new() -> Self {
SettingsBuilder {
_state: PhantomData,
_fields: (None, None, None),
_type: PhantomData,
}
}
}
impl<S: BosStr> SettingsBuilder<settings_state::Empty, S> {
/// Create a new builder with all fields unset
pub fn builder() -> Self {
SettingsBuilder {
_state: PhantomData,
_fields: (None, None, None),
_type: PhantomData,
}
}
}
impl<St, S: BosStr> SettingsBuilder<St, S>
where
St: settings_state::State,
St::CreatedAt: settings_state::IsUnset,
{
/// Set the `createdAt` field (required)
pub fn created_at(
mut self,
value: impl Into<Datetime>,
) -> SettingsBuilder<settings_state::SetCreatedAt<St>, S> {
self._fields.0 = Option::Some(value.into());
SettingsBuilder {
_state: PhantomData,
_fields: self._fields,
_type: PhantomData,
}
}
}
impl<St, S: BosStr> SettingsBuilder<St, S>
where
St: settings_state::State,
St::UpdatedAt: settings_state::IsUnset,
{
/// Set the `updatedAt` field (required)
pub fn updated_at(
mut self,
value: impl Into<Datetime>,
) -> SettingsBuilder<settings_state::SetUpdatedAt<St>, S> {
self._fields.1 = Option::Some(value.into());
SettingsBuilder {
_state: PhantomData,
_fields: self._fields,
_type: PhantomData,
}
}
}
impl<St, S: BosStr> SettingsBuilder<St, S>
where
St: settings_state::State,
St::Version: settings_state::IsUnset,
{
/// Set the `version` field (required)
pub fn version(
mut self,
value: impl Into<i64>,
) -> SettingsBuilder<settings_state::SetVersion<St>, S> {
self._fields.2 = Option::Some(value.into());
SettingsBuilder {
_state: PhantomData,
_fields: self._fields,
_type: PhantomData,
}
}
}
impl<St, S: BosStr> SettingsBuilder<St, S>
where
St: settings_state::State,
St::CreatedAt: settings_state::IsSet,
St::UpdatedAt: settings_state::IsSet,
St::Version: settings_state::IsSet,
{
/// Build the final struct.
pub fn build(self) -> Settings<S> {
Settings {
created_at: self._fields.0.unwrap(),
updated_at: self._fields.1.unwrap(),
version: self._fields.2.unwrap(),
extra_data: Default::default(),
}
}
/// Build the final struct with custom extra_data.
pub fn build_with_data(self, extra_data: BTreeMap<SmolStr, Data<S>>) -> Settings<S> {
Settings {
created_at: self._fields.0.unwrap(),
updated_at: self._fields.1.unwrap(),
version: self._fields.2.unwrap(),
extra_data: Some(extra_data),
}
}
}
fn lexicon_doc_net_anisota_settings() -> LexiconDoc<'static> {
use alloc::collections::BTreeMap;
#[allow(unused_imports)]
use jacquard_common::{CowStr, deps::smol_str::SmolStr, types::blob::MimeType};
use jacquard_lexicon::lexicon::*;
LexiconDoc {
lexicon: Lexicon::Lexicon1,
id: CowStr::new_static("net.anisota.settings"),
defs: {
let mut map = BTreeMap::new();
map.insert(
SmolStr::new_static("main"),
LexUserType::Record(LexRecord {
description: Some(
CowStr::new_static(
"User settings for the Anisota app, synced across devices via ATProto. The collection holds one record per category, keyed by category name: 'appearance', 'behavior', 'notifications', 'chat', 'moderation', 'controls', 'observatory', 'keyboard', 'atmosphere', 'posting'. A special 'index' rkey holds a map of category names to their latest updatedAt timestamp so clients can fetch only categories whose state has drifted. The legacy 'settings' rkey is the deprecated v27 monolithic record; clients run a one-time migration that splits it into the per-category records (atomically via com.atproto.repo.applyWrites) and deletes it. Each category's full shape is defined and validated client-side via scripts/validate-settings-lexicons.js — this lexicon only enforces the universal metadata fields so new per-category fields can ship without a lexicon migration.",
),
),
key: Some(CowStr::new_static("any")),
record: LexRecordRecord::Object(LexObject {
required: Some(
vec![
SmolStr::new_static("version"),
SmolStr::new_static("createdAt"),
SmolStr::new_static("updatedAt")
],
),
properties: {
#[allow(unused_mut)]
let mut map = BTreeMap::new();
map.insert(
SmolStr::new_static("createdAt"),
LexObjectProperty::String(LexString {
description: Some(
CowStr::new_static(
"When this category record was first created",
),
),
format: Some(LexStringFormat::Datetime),
..Default::default()
}),
);
map.insert(
SmolStr::new_static("updatedAt"),
LexObjectProperty::String(LexString {
description: Some(
CowStr::new_static(
"When this category record was last modified",
),
),
format: Some(LexStringFormat::Datetime),
..Default::default()
}),
);
map.insert(
SmolStr::new_static("version"),
LexObjectProperty::Integer(LexInteger {
minimum: Some(1i64),
..Default::default()
}),
);
map
},
..Default::default()
}),
..Default::default()
}),
);
map
},
..Default::default()
}
}