nonbinary.computer
atproto blogging
1// @generated by jacquard-lexicon. DO NOT EDIT.
2//
3// Lexicon: com.whtwnd.blog.defs
4//
5// This file was automatically generated from Lexicon schemas.
6// Any manual changes will be overwritten on the next regeneration.
7
8pub mod entry;
9pub mod get_author_posts;
10pub mod get_entry_metadata_by_name;
11pub mod get_mentions_by_entry;
12pub mod notify_of_new_entry;
13
14#[jacquard_derive::lexicon]
15#[derive(
16 serde::Serialize,
17 serde::Deserialize,
18 Debug,
19 Clone,
20 PartialEq,
21 Eq,
22 jacquard_derive::IntoStatic
23)]
24#[serde(rename_all = "camelCase")]
25pub struct BlobMetadata<'a> {
26 #[serde(borrow)]
27 pub blobref: jacquard_common::types::blob::BlobRef<'a>,
28 #[serde(skip_serializing_if = "std::option::Option::is_none")]
29 #[serde(borrow)]
30 pub name: std::option::Option<jacquard_common::CowStr<'a>>,
31}
32
33pub mod blob_metadata_state {
34
35 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
36 #[allow(unused)]
37 use ::core::marker::PhantomData;
38 mod sealed {
39 pub trait Sealed {}
40 }
41 /// State trait tracking which required fields have been set
42 pub trait State: sealed::Sealed {
43 type Blobref;
44 }
45 /// Empty state - all required fields are unset
46 pub struct Empty(());
47 impl sealed::Sealed for Empty {}
48 impl State for Empty {
49 type Blobref = Unset;
50 }
51 ///State transition - sets the `blobref` field to Set
52 pub struct SetBlobref<S: State = Empty>(PhantomData<fn() -> S>);
53 impl<S: State> sealed::Sealed for SetBlobref<S> {}
54 impl<S: State> State for SetBlobref<S> {
55 type Blobref = Set<members::blobref>;
56 }
57 /// Marker types for field names
58 #[allow(non_camel_case_types)]
59 pub mod members {
60 ///Marker type for the `blobref` field
61 pub struct blobref(());
62 }
63}
64
65/// Builder for constructing an instance of this type
66pub struct BlobMetadataBuilder<'a, S: blob_metadata_state::State> {
67 _phantom_state: ::core::marker::PhantomData<fn() -> S>,
68 __unsafe_private_named: (
69 ::core::option::Option<jacquard_common::types::blob::BlobRef<'a>>,
70 ::core::option::Option<jacquard_common::CowStr<'a>>,
71 ),
72 _phantom: ::core::marker::PhantomData<&'a ()>,
73}
74
75impl<'a> BlobMetadata<'a> {
76 /// Create a new builder for this type
77 pub fn new() -> BlobMetadataBuilder<'a, blob_metadata_state::Empty> {
78 BlobMetadataBuilder::new()
79 }
80}
81
82impl<'a> BlobMetadataBuilder<'a, blob_metadata_state::Empty> {
83 /// Create a new builder with all fields unset
84 pub fn new() -> Self {
85 BlobMetadataBuilder {
86 _phantom_state: ::core::marker::PhantomData,
87 __unsafe_private_named: (None, None),
88 _phantom: ::core::marker::PhantomData,
89 }
90 }
91}
92
93impl<'a, S> BlobMetadataBuilder<'a, S>
94where
95 S: blob_metadata_state::State,
96 S::Blobref: blob_metadata_state::IsUnset,
97{
98 /// Set the `blobref` field (required)
99 pub fn blobref(
100 mut self,
101 value: impl Into<jacquard_common::types::blob::BlobRef<'a>>,
102 ) -> BlobMetadataBuilder<'a, blob_metadata_state::SetBlobref<S>> {
103 self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
104 BlobMetadataBuilder {
105 _phantom_state: ::core::marker::PhantomData,
106 __unsafe_private_named: self.__unsafe_private_named,
107 _phantom: ::core::marker::PhantomData,
108 }
109 }
110}
111
112impl<'a, S: blob_metadata_state::State> BlobMetadataBuilder<'a, S> {
113 /// Set the `name` field (optional)
114 pub fn name(
115 mut self,
116 value: impl Into<Option<jacquard_common::CowStr<'a>>>,
117 ) -> Self {
118 self.__unsafe_private_named.1 = value.into();
119 self
120 }
121 /// Set the `name` field to an Option value (optional)
122 pub fn maybe_name(mut self, value: Option<jacquard_common::CowStr<'a>>) -> Self {
123 self.__unsafe_private_named.1 = value;
124 self
125 }
126}
127
128impl<'a, S> BlobMetadataBuilder<'a, S>
129where
130 S: blob_metadata_state::State,
131 S::Blobref: blob_metadata_state::IsSet,
132{
133 /// Build the final struct
134 pub fn build(self) -> BlobMetadata<'a> {
135 BlobMetadata {
136 blobref: self.__unsafe_private_named.0.unwrap(),
137 name: self.__unsafe_private_named.1,
138 extra_data: Default::default(),
139 }
140 }
141 /// Build the final struct with custom extra_data
142 pub fn build_with_data(
143 self,
144 extra_data: std::collections::BTreeMap<
145 jacquard_common::smol_str::SmolStr,
146 jacquard_common::types::value::Data<'a>,
147 >,
148 ) -> BlobMetadata<'a> {
149 BlobMetadata {
150 blobref: self.__unsafe_private_named.0.unwrap(),
151 name: self.__unsafe_private_named.1,
152 extra_data: Some(extra_data),
153 }
154 }
155}
156
157fn lexicon_doc_com_whtwnd_blog_defs() -> ::jacquard_lexicon::lexicon::LexiconDoc<
158 'static,
159> {
160 ::jacquard_lexicon::lexicon::LexiconDoc {
161 lexicon: ::jacquard_lexicon::lexicon::Lexicon::Lexicon1,
162 id: ::jacquard_common::CowStr::new_static("com.whtwnd.blog.defs"),
163 revision: None,
164 description: None,
165 defs: {
166 let mut map = ::alloc::collections::BTreeMap::new();
167 map.insert(
168 ::jacquard_common::smol_str::SmolStr::new_static("blobMetadata"),
169 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
170 description: None,
171 required: Some(
172 vec![::jacquard_common::smol_str::SmolStr::new_static("blobref")],
173 ),
174 nullable: None,
175 properties: {
176 #[allow(unused_mut)]
177 let mut map = ::alloc::collections::BTreeMap::new();
178 map.insert(
179 ::jacquard_common::smol_str::SmolStr::new_static("blobref"),
180 ::jacquard_lexicon::lexicon::LexObjectProperty::Blob(::jacquard_lexicon::lexicon::LexBlob {
181 description: None,
182 accept: None,
183 max_size: None,
184 }),
185 );
186 map.insert(
187 ::jacquard_common::smol_str::SmolStr::new_static("name"),
188 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
189 description: None,
190 format: None,
191 default: None,
192 min_length: None,
193 max_length: None,
194 min_graphemes: None,
195 max_graphemes: None,
196 r#enum: None,
197 r#const: None,
198 known_values: None,
199 }),
200 );
201 map
202 },
203 }),
204 );
205 map.insert(
206 ::jacquard_common::smol_str::SmolStr::new_static("blogEntry"),
207 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
208 description: None,
209 required: Some(
210 vec![::jacquard_common::smol_str::SmolStr::new_static("content")],
211 ),
212 nullable: None,
213 properties: {
214 #[allow(unused_mut)]
215 let mut map = ::alloc::collections::BTreeMap::new();
216 map.insert(
217 ::jacquard_common::smol_str::SmolStr::new_static("content"),
218 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
219 description: None,
220 format: None,
221 default: None,
222 min_length: None,
223 max_length: Some(100000usize),
224 min_graphemes: None,
225 max_graphemes: None,
226 r#enum: None,
227 r#const: None,
228 known_values: None,
229 }),
230 );
231 map.insert(
232 ::jacquard_common::smol_str::SmolStr::new_static(
233 "createdAt",
234 ),
235 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
236 description: None,
237 format: Some(
238 ::jacquard_lexicon::lexicon::LexStringFormat::Datetime,
239 ),
240 default: None,
241 min_length: None,
242 max_length: None,
243 min_graphemes: None,
244 max_graphemes: None,
245 r#enum: None,
246 r#const: None,
247 known_values: None,
248 }),
249 );
250 map
251 },
252 }),
253 );
254 map.insert(
255 ::jacquard_common::smol_str::SmolStr::new_static("comment"),
256 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
257 description: None,
258 required: Some(
259 vec![
260 ::jacquard_common::smol_str::SmolStr::new_static("content"),
261 ::jacquard_common::smol_str::SmolStr::new_static("entryUri")
262 ],
263 ),
264 nullable: None,
265 properties: {
266 #[allow(unused_mut)]
267 let mut map = ::alloc::collections::BTreeMap::new();
268 map.insert(
269 ::jacquard_common::smol_str::SmolStr::new_static("content"),
270 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
271 description: None,
272 format: None,
273 default: None,
274 min_length: None,
275 max_length: Some(1000usize),
276 min_graphemes: None,
277 max_graphemes: None,
278 r#enum: None,
279 r#const: None,
280 known_values: None,
281 }),
282 );
283 map.insert(
284 ::jacquard_common::smol_str::SmolStr::new_static("entryUri"),
285 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
286 description: None,
287 format: Some(
288 ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
289 ),
290 default: None,
291 min_length: None,
292 max_length: None,
293 min_graphemes: None,
294 max_graphemes: None,
295 r#enum: None,
296 r#const: None,
297 known_values: None,
298 }),
299 );
300 map
301 },
302 }),
303 );
304 map.insert(
305 ::jacquard_common::smol_str::SmolStr::new_static("ogp"),
306 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
307 description: None,
308 required: Some(
309 vec![::jacquard_common::smol_str::SmolStr::new_static("url")],
310 ),
311 nullable: None,
312 properties: {
313 #[allow(unused_mut)]
314 let mut map = ::alloc::collections::BTreeMap::new();
315 map.insert(
316 ::jacquard_common::smol_str::SmolStr::new_static("height"),
317 ::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger {
318 description: None,
319 default: None,
320 minimum: None,
321 maximum: None,
322 r#enum: None,
323 r#const: None,
324 }),
325 );
326 map.insert(
327 ::jacquard_common::smol_str::SmolStr::new_static("url"),
328 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
329 description: None,
330 format: Some(
331 ::jacquard_lexicon::lexicon::LexStringFormat::Uri,
332 ),
333 default: None,
334 min_length: None,
335 max_length: None,
336 min_graphemes: None,
337 max_graphemes: None,
338 r#enum: None,
339 r#const: None,
340 known_values: None,
341 }),
342 );
343 map.insert(
344 ::jacquard_common::smol_str::SmolStr::new_static("width"),
345 ::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger {
346 description: None,
347 default: None,
348 minimum: None,
349 maximum: None,
350 r#enum: None,
351 r#const: None,
352 }),
353 );
354 map
355 },
356 }),
357 );
358 map
359 },
360 }
361}
362
363impl<'a> ::jacquard_lexicon::schema::LexiconSchema for BlobMetadata<'a> {
364 fn nsid() -> &'static str {
365 "com.whtwnd.blog.defs"
366 }
367 fn def_name() -> &'static str {
368 "blobMetadata"
369 }
370 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
371 lexicon_doc_com_whtwnd_blog_defs()
372 }
373 fn validate(
374 &self,
375 ) -> ::core::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
376 Ok(())
377 }
378}
379
380#[jacquard_derive::lexicon]
381#[derive(
382 serde::Serialize,
383 serde::Deserialize,
384 Debug,
385 Clone,
386 PartialEq,
387 Eq,
388 jacquard_derive::IntoStatic,
389 Default
390)]
391#[serde(rename_all = "camelCase")]
392pub struct BlogEntry<'a> {
393 #[serde(borrow)]
394 pub content: jacquard_common::CowStr<'a>,
395 #[serde(skip_serializing_if = "std::option::Option::is_none")]
396 pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,
397}
398
399impl<'a> ::jacquard_lexicon::schema::LexiconSchema for BlogEntry<'a> {
400 fn nsid() -> &'static str {
401 "com.whtwnd.blog.defs"
402 }
403 fn def_name() -> &'static str {
404 "blogEntry"
405 }
406 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
407 lexicon_doc_com_whtwnd_blog_defs()
408 }
409 fn validate(
410 &self,
411 ) -> ::core::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
412 {
413 let value = &self.content;
414 #[allow(unused_comparisons)]
415 if <str>::len(value.as_ref()) > 100000usize {
416 return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
417 path: ::jacquard_lexicon::validation::ValidationPath::from_field(
418 "content",
419 ),
420 max: 100000usize,
421 actual: <str>::len(value.as_ref()),
422 });
423 }
424 }
425 Ok(())
426 }
427}
428
429#[jacquard_derive::lexicon]
430#[derive(
431 serde::Serialize,
432 serde::Deserialize,
433 Debug,
434 Clone,
435 PartialEq,
436 Eq,
437 jacquard_derive::IntoStatic
438)]
439#[serde(rename_all = "camelCase")]
440pub struct Comment<'a> {
441 #[serde(borrow)]
442 pub content: jacquard_common::CowStr<'a>,
443 #[serde(borrow)]
444 pub entry_uri: jacquard_common::types::string::AtUri<'a>,
445}
446
447pub mod comment_state {
448
449 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
450 #[allow(unused)]
451 use ::core::marker::PhantomData;
452 mod sealed {
453 pub trait Sealed {}
454 }
455 /// State trait tracking which required fields have been set
456 pub trait State: sealed::Sealed {
457 type Content;
458 type EntryUri;
459 }
460 /// Empty state - all required fields are unset
461 pub struct Empty(());
462 impl sealed::Sealed for Empty {}
463 impl State for Empty {
464 type Content = Unset;
465 type EntryUri = Unset;
466 }
467 ///State transition - sets the `content` field to Set
468 pub struct SetContent<S: State = Empty>(PhantomData<fn() -> S>);
469 impl<S: State> sealed::Sealed for SetContent<S> {}
470 impl<S: State> State for SetContent<S> {
471 type Content = Set<members::content>;
472 type EntryUri = S::EntryUri;
473 }
474 ///State transition - sets the `entry_uri` field to Set
475 pub struct SetEntryUri<S: State = Empty>(PhantomData<fn() -> S>);
476 impl<S: State> sealed::Sealed for SetEntryUri<S> {}
477 impl<S: State> State for SetEntryUri<S> {
478 type Content = S::Content;
479 type EntryUri = Set<members::entry_uri>;
480 }
481 /// Marker types for field names
482 #[allow(non_camel_case_types)]
483 pub mod members {
484 ///Marker type for the `content` field
485 pub struct content(());
486 ///Marker type for the `entry_uri` field
487 pub struct entry_uri(());
488 }
489}
490
491/// Builder for constructing an instance of this type
492pub struct CommentBuilder<'a, S: comment_state::State> {
493 _phantom_state: ::core::marker::PhantomData<fn() -> S>,
494 __unsafe_private_named: (
495 ::core::option::Option<jacquard_common::CowStr<'a>>,
496 ::core::option::Option<jacquard_common::types::string::AtUri<'a>>,
497 ),
498 _phantom: ::core::marker::PhantomData<&'a ()>,
499}
500
501impl<'a> Comment<'a> {
502 /// Create a new builder for this type
503 pub fn new() -> CommentBuilder<'a, comment_state::Empty> {
504 CommentBuilder::new()
505 }
506}
507
508impl<'a> CommentBuilder<'a, comment_state::Empty> {
509 /// Create a new builder with all fields unset
510 pub fn new() -> Self {
511 CommentBuilder {
512 _phantom_state: ::core::marker::PhantomData,
513 __unsafe_private_named: (None, None),
514 _phantom: ::core::marker::PhantomData,
515 }
516 }
517}
518
519impl<'a, S> CommentBuilder<'a, S>
520where
521 S: comment_state::State,
522 S::Content: comment_state::IsUnset,
523{
524 /// Set the `content` field (required)
525 pub fn content(
526 mut self,
527 value: impl Into<jacquard_common::CowStr<'a>>,
528 ) -> CommentBuilder<'a, comment_state::SetContent<S>> {
529 self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
530 CommentBuilder {
531 _phantom_state: ::core::marker::PhantomData,
532 __unsafe_private_named: self.__unsafe_private_named,
533 _phantom: ::core::marker::PhantomData,
534 }
535 }
536}
537
538impl<'a, S> CommentBuilder<'a, S>
539where
540 S: comment_state::State,
541 S::EntryUri: comment_state::IsUnset,
542{
543 /// Set the `entryUri` field (required)
544 pub fn entry_uri(
545 mut self,
546 value: impl Into<jacquard_common::types::string::AtUri<'a>>,
547 ) -> CommentBuilder<'a, comment_state::SetEntryUri<S>> {
548 self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
549 CommentBuilder {
550 _phantom_state: ::core::marker::PhantomData,
551 __unsafe_private_named: self.__unsafe_private_named,
552 _phantom: ::core::marker::PhantomData,
553 }
554 }
555}
556
557impl<'a, S> CommentBuilder<'a, S>
558where
559 S: comment_state::State,
560 S::Content: comment_state::IsSet,
561 S::EntryUri: comment_state::IsSet,
562{
563 /// Build the final struct
564 pub fn build(self) -> Comment<'a> {
565 Comment {
566 content: self.__unsafe_private_named.0.unwrap(),
567 entry_uri: self.__unsafe_private_named.1.unwrap(),
568 extra_data: Default::default(),
569 }
570 }
571 /// Build the final struct with custom extra_data
572 pub fn build_with_data(
573 self,
574 extra_data: std::collections::BTreeMap<
575 jacquard_common::smol_str::SmolStr,
576 jacquard_common::types::value::Data<'a>,
577 >,
578 ) -> Comment<'a> {
579 Comment {
580 content: self.__unsafe_private_named.0.unwrap(),
581 entry_uri: self.__unsafe_private_named.1.unwrap(),
582 extra_data: Some(extra_data),
583 }
584 }
585}
586
587impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Comment<'a> {
588 fn nsid() -> &'static str {
589 "com.whtwnd.blog.defs"
590 }
591 fn def_name() -> &'static str {
592 "comment"
593 }
594 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
595 lexicon_doc_com_whtwnd_blog_defs()
596 }
597 fn validate(
598 &self,
599 ) -> ::core::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
600 {
601 let value = &self.content;
602 #[allow(unused_comparisons)]
603 if <str>::len(value.as_ref()) > 1000usize {
604 return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
605 path: ::jacquard_lexicon::validation::ValidationPath::from_field(
606 "content",
607 ),
608 max: 1000usize,
609 actual: <str>::len(value.as_ref()),
610 });
611 }
612 }
613 Ok(())
614 }
615}
616
617#[jacquard_derive::lexicon]
618#[derive(
619 serde::Serialize,
620 serde::Deserialize,
621 Debug,
622 Clone,
623 PartialEq,
624 Eq,
625 jacquard_derive::IntoStatic
626)]
627#[serde(rename_all = "camelCase")]
628pub struct Ogp<'a> {
629 #[serde(skip_serializing_if = "std::option::Option::is_none")]
630 pub height: std::option::Option<i64>,
631 #[serde(borrow)]
632 pub url: jacquard_common::types::string::Uri<'a>,
633 #[serde(skip_serializing_if = "std::option::Option::is_none")]
634 pub width: std::option::Option<i64>,
635}
636
637pub mod ogp_state {
638
639 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
640 #[allow(unused)]
641 use ::core::marker::PhantomData;
642 mod sealed {
643 pub trait Sealed {}
644 }
645 /// State trait tracking which required fields have been set
646 pub trait State: sealed::Sealed {
647 type Url;
648 }
649 /// Empty state - all required fields are unset
650 pub struct Empty(());
651 impl sealed::Sealed for Empty {}
652 impl State for Empty {
653 type Url = Unset;
654 }
655 ///State transition - sets the `url` field to Set
656 pub struct SetUrl<S: State = Empty>(PhantomData<fn() -> S>);
657 impl<S: State> sealed::Sealed for SetUrl<S> {}
658 impl<S: State> State for SetUrl<S> {
659 type Url = Set<members::url>;
660 }
661 /// Marker types for field names
662 #[allow(non_camel_case_types)]
663 pub mod members {
664 ///Marker type for the `url` field
665 pub struct url(());
666 }
667}
668
669/// Builder for constructing an instance of this type
670pub struct OgpBuilder<'a, S: ogp_state::State> {
671 _phantom_state: ::core::marker::PhantomData<fn() -> S>,
672 __unsafe_private_named: (
673 ::core::option::Option<i64>,
674 ::core::option::Option<jacquard_common::types::string::Uri<'a>>,
675 ::core::option::Option<i64>,
676 ),
677 _phantom: ::core::marker::PhantomData<&'a ()>,
678}
679
680impl<'a> Ogp<'a> {
681 /// Create a new builder for this type
682 pub fn new() -> OgpBuilder<'a, ogp_state::Empty> {
683 OgpBuilder::new()
684 }
685}
686
687impl<'a> OgpBuilder<'a, ogp_state::Empty> {
688 /// Create a new builder with all fields unset
689 pub fn new() -> Self {
690 OgpBuilder {
691 _phantom_state: ::core::marker::PhantomData,
692 __unsafe_private_named: (None, None, None),
693 _phantom: ::core::marker::PhantomData,
694 }
695 }
696}
697
698impl<'a, S: ogp_state::State> OgpBuilder<'a, S> {
699 /// Set the `height` field (optional)
700 pub fn height(mut self, value: impl Into<Option<i64>>) -> Self {
701 self.__unsafe_private_named.0 = value.into();
702 self
703 }
704 /// Set the `height` field to an Option value (optional)
705 pub fn maybe_height(mut self, value: Option<i64>) -> Self {
706 self.__unsafe_private_named.0 = value;
707 self
708 }
709}
710
711impl<'a, S> OgpBuilder<'a, S>
712where
713 S: ogp_state::State,
714 S::Url: ogp_state::IsUnset,
715{
716 /// Set the `url` field (required)
717 pub fn url(
718 mut self,
719 value: impl Into<jacquard_common::types::string::Uri<'a>>,
720 ) -> OgpBuilder<'a, ogp_state::SetUrl<S>> {
721 self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
722 OgpBuilder {
723 _phantom_state: ::core::marker::PhantomData,
724 __unsafe_private_named: self.__unsafe_private_named,
725 _phantom: ::core::marker::PhantomData,
726 }
727 }
728}
729
730impl<'a, S: ogp_state::State> OgpBuilder<'a, S> {
731 /// Set the `width` field (optional)
732 pub fn width(mut self, value: impl Into<Option<i64>>) -> Self {
733 self.__unsafe_private_named.2 = value.into();
734 self
735 }
736 /// Set the `width` field to an Option value (optional)
737 pub fn maybe_width(mut self, value: Option<i64>) -> Self {
738 self.__unsafe_private_named.2 = value;
739 self
740 }
741}
742
743impl<'a, S> OgpBuilder<'a, S>
744where
745 S: ogp_state::State,
746 S::Url: ogp_state::IsSet,
747{
748 /// Build the final struct
749 pub fn build(self) -> Ogp<'a> {
750 Ogp {
751 height: self.__unsafe_private_named.0,
752 url: self.__unsafe_private_named.1.unwrap(),
753 width: self.__unsafe_private_named.2,
754 extra_data: Default::default(),
755 }
756 }
757 /// Build the final struct with custom extra_data
758 pub fn build_with_data(
759 self,
760 extra_data: std::collections::BTreeMap<
761 jacquard_common::smol_str::SmolStr,
762 jacquard_common::types::value::Data<'a>,
763 >,
764 ) -> Ogp<'a> {
765 Ogp {
766 height: self.__unsafe_private_named.0,
767 url: self.__unsafe_private_named.1.unwrap(),
768 width: self.__unsafe_private_named.2,
769 extra_data: Some(extra_data),
770 }
771 }
772}
773
774impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Ogp<'a> {
775 fn nsid() -> &'static str {
776 "com.whtwnd.blog.defs"
777 }
778 fn def_name() -> &'static str {
779 "ogp"
780 }
781 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
782 lexicon_doc_com_whtwnd_blog_defs()
783 }
784 fn validate(
785 &self,
786 ) -> ::core::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
787 Ok(())
788 }
789}