jacquard_api/chat_bsky/group/
reject_join_request.rs1#[allow(unused_imports)]
9use alloc::collections::BTreeMap;
10
11#[allow(unused_imports)]
12use core::marker::PhantomData;
13use jacquard_common::deps::smol_str::SmolStr;
14use jacquard_common::types::string::Did;
15use jacquard_common::types::value::Data;
16use jacquard_common::{BosStr, CowStr, DefaultStr, FromStaticStr};
17use jacquard_derive::{IntoStatic, open_union};
18use serde::{Deserialize, Serialize};
19
20#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
21#[serde(
22 rename_all = "camelCase",
23 bound(deserialize = "S: Deserialize<'de> + BosStr")
24)]
25pub struct RejectJoinRequest<S: BosStr = DefaultStr> {
26 pub convo_id: S,
27 pub member: Did<S>,
28 #[serde(flatten, default, skip_serializing_if = "Option::is_none")]
29 pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,
30}
31
32#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
33#[serde(
34 rename_all = "camelCase",
35 bound(deserialize = "S: Deserialize<'de> + BosStr")
36)]
37pub struct RejectJoinRequestOutput<S: BosStr = DefaultStr> {
38 #[serde(flatten, default, skip_serializing_if = "Option::is_none")]
39 pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,
40}
41
42#[derive(
43 Serialize, Deserialize, Debug, Clone, PartialEq, Eq, thiserror::Error, miette::Diagnostic,
44)]
45#[serde(tag = "error", content = "message")]
46pub enum RejectJoinRequestError {
47 #[serde(rename = "InvalidConvo")]
48 InvalidConvo(Option<SmolStr>),
49 #[serde(rename = "InsufficientRole")]
50 InsufficientRole(Option<SmolStr>),
51 #[serde(untagged)]
53 Other {
54 error: SmolStr,
55 message: Option<SmolStr>,
56 },
57}
58
59impl core::fmt::Display for RejectJoinRequestError {
60 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
61 match self {
62 Self::InvalidConvo(msg) => {
63 write!(f, "InvalidConvo")?;
64 if let Some(msg) = msg {
65 write!(f, ": {}", msg)?;
66 }
67 Ok(())
68 }
69 Self::InsufficientRole(msg) => {
70 write!(f, "InsufficientRole")?;
71 if let Some(msg) = msg {
72 write!(f, ": {}", msg)?;
73 }
74 Ok(())
75 }
76 Self::Other { error, message } => {
77 write!(f, "{}", error)?;
78 if let Some(msg) = message {
79 write!(f, ": {}", msg)?;
80 }
81 Ok(())
82 }
83 }
84 }
85}
86
87pub struct RejectJoinRequestResponse;
91impl jacquard_common::xrpc::XrpcResp for RejectJoinRequestResponse {
92 const NSID: &'static str = "chat.bsky.group.rejectJoinRequest";
93 const ENCODING: &'static str = "application/json";
94 type Output<S: BosStr> = RejectJoinRequestOutput<S>;
95 type Err = RejectJoinRequestError;
96}
97
98impl<S: BosStr> jacquard_common::xrpc::XrpcRequest for RejectJoinRequest<S> {
99 const NSID: &'static str = "chat.bsky.group.rejectJoinRequest";
100 const METHOD: jacquard_common::xrpc::XrpcMethod =
101 jacquard_common::xrpc::XrpcMethod::Procedure("application/json");
102 type Response = RejectJoinRequestResponse;
103}
104
105pub struct RejectJoinRequestRequest;
109impl jacquard_common::xrpc::XrpcEndpoint for RejectJoinRequestRequest {
110 const PATH: &'static str = "/xrpc/chat.bsky.group.rejectJoinRequest";
111 const METHOD: jacquard_common::xrpc::XrpcMethod =
112 jacquard_common::xrpc::XrpcMethod::Procedure("application/json");
113 type Request<S: BosStr> = RejectJoinRequest<S>;
114 type Response = RejectJoinRequestResponse;
115}
116
117pub mod reject_join_request_state {
118
119 pub use crate::builder_types::{IsSet, IsUnset, Set, Unset};
120 #[allow(unused)]
121 use ::core::marker::PhantomData;
122 mod sealed {
123 pub trait Sealed {}
124 }
125 pub trait State: sealed::Sealed {
127 type ConvoId;
128 type Member;
129 }
130 pub struct Empty(());
132 impl sealed::Sealed for Empty {}
133 impl State for Empty {
134 type ConvoId = Unset;
135 type Member = Unset;
136 }
137 pub struct SetConvoId<St: State = Empty>(PhantomData<fn() -> St>);
139 impl<St: State> sealed::Sealed for SetConvoId<St> {}
140 impl<St: State> State for SetConvoId<St> {
141 type ConvoId = Set<members::convo_id>;
142 type Member = St::Member;
143 }
144 pub struct SetMember<St: State = Empty>(PhantomData<fn() -> St>);
146 impl<St: State> sealed::Sealed for SetMember<St> {}
147 impl<St: State> State for SetMember<St> {
148 type ConvoId = St::ConvoId;
149 type Member = Set<members::member>;
150 }
151 #[allow(non_camel_case_types)]
153 pub mod members {
154 pub struct convo_id(());
156 pub struct member(());
158 }
159}
160
161pub struct RejectJoinRequestBuilder<St: reject_join_request_state::State, S: BosStr = DefaultStr> {
163 _state: PhantomData<fn() -> St>,
164 _fields: (Option<S>, Option<Did<S>>),
165 _type: PhantomData<fn() -> S>,
166}
167
168impl RejectJoinRequest<DefaultStr> {
169 pub fn new() -> RejectJoinRequestBuilder<reject_join_request_state::Empty, DefaultStr> {
171 RejectJoinRequestBuilder::new()
172 }
173}
174
175impl<S: BosStr> RejectJoinRequest<S> {
176 pub fn builder() -> RejectJoinRequestBuilder<reject_join_request_state::Empty, S> {
178 RejectJoinRequestBuilder::builder()
179 }
180}
181
182impl RejectJoinRequestBuilder<reject_join_request_state::Empty, DefaultStr> {
183 pub fn new() -> Self {
185 RejectJoinRequestBuilder {
186 _state: PhantomData,
187 _fields: (None, None),
188 _type: PhantomData,
189 }
190 }
191}
192
193impl<S: BosStr> RejectJoinRequestBuilder<reject_join_request_state::Empty, S> {
194 pub fn builder() -> Self {
196 RejectJoinRequestBuilder {
197 _state: PhantomData,
198 _fields: (None, None),
199 _type: PhantomData,
200 }
201 }
202}
203
204impl<St, S: BosStr> RejectJoinRequestBuilder<St, S>
205where
206 St: reject_join_request_state::State,
207 St::ConvoId: reject_join_request_state::IsUnset,
208{
209 pub fn convo_id(
211 mut self,
212 value: impl Into<S>,
213 ) -> RejectJoinRequestBuilder<reject_join_request_state::SetConvoId<St>, S> {
214 self._fields.0 = Option::Some(value.into());
215 RejectJoinRequestBuilder {
216 _state: PhantomData,
217 _fields: self._fields,
218 _type: PhantomData,
219 }
220 }
221}
222
223impl<St, S: BosStr> RejectJoinRequestBuilder<St, S>
224where
225 St: reject_join_request_state::State,
226 St::Member: reject_join_request_state::IsUnset,
227{
228 pub fn member(
230 mut self,
231 value: impl Into<Did<S>>,
232 ) -> RejectJoinRequestBuilder<reject_join_request_state::SetMember<St>, S> {
233 self._fields.1 = Option::Some(value.into());
234 RejectJoinRequestBuilder {
235 _state: PhantomData,
236 _fields: self._fields,
237 _type: PhantomData,
238 }
239 }
240}
241
242impl<St, S: BosStr> RejectJoinRequestBuilder<St, S>
243where
244 St: reject_join_request_state::State,
245 St::ConvoId: reject_join_request_state::IsSet,
246 St::Member: reject_join_request_state::IsSet,
247{
248 pub fn build(self) -> RejectJoinRequest<S> {
250 RejectJoinRequest {
251 convo_id: self._fields.0.unwrap(),
252 member: self._fields.1.unwrap(),
253 extra_data: Default::default(),
254 }
255 }
256 pub fn build_with_data(self, extra_data: BTreeMap<SmolStr, Data<S>>) -> RejectJoinRequest<S> {
258 RejectJoinRequest {
259 convo_id: self._fields.0.unwrap(),
260 member: self._fields.1.unwrap(),
261 extra_data: Some(extra_data),
262 }
263 }
264}