jacquard_api/app_bsky/notification/
put_activity_subscription.rs1#[allow(unused_imports)]
9use alloc::collections::BTreeMap;
10
11#[allow(unused_imports)]
12use core::marker::PhantomData;
13use jacquard_common::types::string::Did;
14use jacquard_derive::{IntoStatic, lexicon};
15use serde::{Serialize, Deserialize};
16use crate::app_bsky::notification::ActivitySubscription;
17
18#[lexicon]
19#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
20#[serde(rename_all = "camelCase")]
21pub struct PutActivitySubscription<'a> {
22 #[serde(borrow)]
23 pub activity_subscription: ActivitySubscription<'a>,
24 #[serde(borrow)]
25 pub subject: Did<'a>,
26}
27
28
29#[lexicon]
30#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
31#[serde(rename_all = "camelCase")]
32pub struct PutActivitySubscriptionOutput<'a> {
33 #[serde(skip_serializing_if = "Option::is_none")]
34 #[serde(borrow)]
35 pub activity_subscription: Option<ActivitySubscription<'a>>,
36 #[serde(borrow)]
37 pub subject: Did<'a>,
38}
39
40pub struct PutActivitySubscriptionResponse;
42impl jacquard_common::xrpc::XrpcResp for PutActivitySubscriptionResponse {
43 const NSID: &'static str = "app.bsky.notification.putActivitySubscription";
44 const ENCODING: &'static str = "application/json";
45 type Output<'de> = PutActivitySubscriptionOutput<'de>;
46 type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
47}
48
49impl<'a> jacquard_common::xrpc::XrpcRequest for PutActivitySubscription<'a> {
50 const NSID: &'static str = "app.bsky.notification.putActivitySubscription";
51 const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
52 "application/json",
53 );
54 type Response = PutActivitySubscriptionResponse;
55}
56
57pub struct PutActivitySubscriptionRequest;
59impl jacquard_common::xrpc::XrpcEndpoint for PutActivitySubscriptionRequest {
60 const PATH: &'static str = "/xrpc/app.bsky.notification.putActivitySubscription";
61 const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
62 "application/json",
63 );
64 type Request<'de> = PutActivitySubscription<'de>;
65 type Response = PutActivitySubscriptionResponse;
66}
67
68pub mod put_activity_subscription_state {
69
70 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
71 #[allow(unused)]
72 use ::core::marker::PhantomData;
73 mod sealed {
74 pub trait Sealed {}
75 }
76 pub trait State: sealed::Sealed {
78 type Subject;
79 type ActivitySubscription;
80 }
81 pub struct Empty(());
83 impl sealed::Sealed for Empty {}
84 impl State for Empty {
85 type Subject = Unset;
86 type ActivitySubscription = Unset;
87 }
88 pub struct SetSubject<S: State = Empty>(PhantomData<fn() -> S>);
90 impl<S: State> sealed::Sealed for SetSubject<S> {}
91 impl<S: State> State for SetSubject<S> {
92 type Subject = Set<members::subject>;
93 type ActivitySubscription = S::ActivitySubscription;
94 }
95 pub struct SetActivitySubscription<S: State = Empty>(PhantomData<fn() -> S>);
97 impl<S: State> sealed::Sealed for SetActivitySubscription<S> {}
98 impl<S: State> State for SetActivitySubscription<S> {
99 type Subject = S::Subject;
100 type ActivitySubscription = Set<members::activity_subscription>;
101 }
102 #[allow(non_camel_case_types)]
104 pub mod members {
105 pub struct subject(());
107 pub struct activity_subscription(());
109 }
110}
111
112pub struct PutActivitySubscriptionBuilder<
114 'a,
115 S: put_activity_subscription_state::State,
116> {
117 _state: PhantomData<fn() -> S>,
118 _fields: (Option<ActivitySubscription<'a>>, Option<Did<'a>>),
119 _lifetime: PhantomData<&'a ()>,
120}
121
122impl<'a> PutActivitySubscription<'a> {
123 pub fn new() -> PutActivitySubscriptionBuilder<
125 'a,
126 put_activity_subscription_state::Empty,
127 > {
128 PutActivitySubscriptionBuilder::new()
129 }
130}
131
132impl<'a> PutActivitySubscriptionBuilder<'a, put_activity_subscription_state::Empty> {
133 pub fn new() -> Self {
135 PutActivitySubscriptionBuilder {
136 _state: PhantomData,
137 _fields: (None, None),
138 _lifetime: PhantomData,
139 }
140 }
141}
142
143impl<'a, S> PutActivitySubscriptionBuilder<'a, S>
144where
145 S: put_activity_subscription_state::State,
146 S::ActivitySubscription: put_activity_subscription_state::IsUnset,
147{
148 pub fn activity_subscription(
150 mut self,
151 value: impl Into<ActivitySubscription<'a>>,
152 ) -> PutActivitySubscriptionBuilder<
153 'a,
154 put_activity_subscription_state::SetActivitySubscription<S>,
155 > {
156 self._fields.0 = Option::Some(value.into());
157 PutActivitySubscriptionBuilder {
158 _state: PhantomData,
159 _fields: self._fields,
160 _lifetime: PhantomData,
161 }
162 }
163}
164
165impl<'a, S> PutActivitySubscriptionBuilder<'a, S>
166where
167 S: put_activity_subscription_state::State,
168 S::Subject: put_activity_subscription_state::IsUnset,
169{
170 pub fn subject(
172 mut self,
173 value: impl Into<Did<'a>>,
174 ) -> PutActivitySubscriptionBuilder<
175 'a,
176 put_activity_subscription_state::SetSubject<S>,
177 > {
178 self._fields.1 = Option::Some(value.into());
179 PutActivitySubscriptionBuilder {
180 _state: PhantomData,
181 _fields: self._fields,
182 _lifetime: PhantomData,
183 }
184 }
185}
186
187impl<'a, S> PutActivitySubscriptionBuilder<'a, S>
188where
189 S: put_activity_subscription_state::State,
190 S::Subject: put_activity_subscription_state::IsSet,
191 S::ActivitySubscription: put_activity_subscription_state::IsSet,
192{
193 pub fn build(self) -> PutActivitySubscription<'a> {
195 PutActivitySubscription {
196 activity_subscription: self._fields.0.unwrap(),
197 subject: self._fields.1.unwrap(),
198 extra_data: Default::default(),
199 }
200 }
201 pub fn build_with_data(
203 self,
204 extra_data: BTreeMap<
205 jacquard_common::deps::smol_str::SmolStr,
206 jacquard_common::types::value::Data<'a>,
207 >,
208 ) -> PutActivitySubscription<'a> {
209 PutActivitySubscription {
210 activity_subscription: self._fields.0.unwrap(),
211 subject: self._fields.1.unwrap(),
212 extra_data: Some(extra_data),
213 }
214 }
215}