jacquard_api/sh_weaver/graph/
get_actor_subscriptions.rs1#[allow(unused_imports)]
9use alloc::collections::BTreeMap;
10
11#[allow(unused_imports)]
12use core::marker::PhantomData;
13use jacquard_common::CowStr;
14use jacquard_common::types::ident::AtIdentifier;
15use jacquard_common::types::value::Data;
16use jacquard_derive::{IntoStatic, lexicon};
17use serde::{Serialize, Deserialize};
18
19#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
20#[serde(rename_all = "camelCase")]
21pub struct GetActorSubscriptions<'a> {
22 #[serde(borrow)]
23 pub actor: AtIdentifier<'a>,
24 #[serde(skip_serializing_if = "Option::is_none")]
25 #[serde(borrow)]
26 pub cursor: Option<CowStr<'a>>,
27 #[serde(default = "_default_limit")]
29 #[serde(skip_serializing_if = "Option::is_none")]
30 pub limit: Option<i64>,
31}
32
33
34#[lexicon]
35#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
36#[serde(rename_all = "camelCase")]
37pub struct GetActorSubscriptionsOutput<'a> {
38 #[serde(skip_serializing_if = "Option::is_none")]
39 #[serde(borrow)]
40 pub cursor: Option<CowStr<'a>>,
41 #[serde(borrow)]
42 pub subscriptions: Vec<Data<'a>>,
43}
44
45pub struct GetActorSubscriptionsResponse;
47impl jacquard_common::xrpc::XrpcResp for GetActorSubscriptionsResponse {
48 const NSID: &'static str = "sh.weaver.graph.getActorSubscriptions";
49 const ENCODING: &'static str = "application/json";
50 type Output<'de> = GetActorSubscriptionsOutput<'de>;
51 type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
52}
53
54impl<'a> jacquard_common::xrpc::XrpcRequest for GetActorSubscriptions<'a> {
55 const NSID: &'static str = "sh.weaver.graph.getActorSubscriptions";
56 const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
57 type Response = GetActorSubscriptionsResponse;
58}
59
60pub struct GetActorSubscriptionsRequest;
62impl jacquard_common::xrpc::XrpcEndpoint for GetActorSubscriptionsRequest {
63 const PATH: &'static str = "/xrpc/sh.weaver.graph.getActorSubscriptions";
64 const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
65 type Request<'de> = GetActorSubscriptions<'de>;
66 type Response = GetActorSubscriptionsResponse;
67}
68
69fn _default_limit() -> Option<i64> {
70 Some(50i64)
71}
72
73pub mod get_actor_subscriptions_state {
74
75 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
76 #[allow(unused)]
77 use ::core::marker::PhantomData;
78 mod sealed {
79 pub trait Sealed {}
80 }
81 pub trait State: sealed::Sealed {
83 type Actor;
84 }
85 pub struct Empty(());
87 impl sealed::Sealed for Empty {}
88 impl State for Empty {
89 type Actor = Unset;
90 }
91 pub struct SetActor<S: State = Empty>(PhantomData<fn() -> S>);
93 impl<S: State> sealed::Sealed for SetActor<S> {}
94 impl<S: State> State for SetActor<S> {
95 type Actor = Set<members::actor>;
96 }
97 #[allow(non_camel_case_types)]
99 pub mod members {
100 pub struct actor(());
102 }
103}
104
105pub struct GetActorSubscriptionsBuilder<'a, S: get_actor_subscriptions_state::State> {
107 _state: PhantomData<fn() -> S>,
108 _fields: (Option<AtIdentifier<'a>>, Option<CowStr<'a>>, Option<i64>),
109 _lifetime: PhantomData<&'a ()>,
110}
111
112impl<'a> GetActorSubscriptions<'a> {
113 pub fn new() -> GetActorSubscriptionsBuilder<
115 'a,
116 get_actor_subscriptions_state::Empty,
117 > {
118 GetActorSubscriptionsBuilder::new()
119 }
120}
121
122impl<'a> GetActorSubscriptionsBuilder<'a, get_actor_subscriptions_state::Empty> {
123 pub fn new() -> Self {
125 GetActorSubscriptionsBuilder {
126 _state: PhantomData,
127 _fields: (None, None, None),
128 _lifetime: PhantomData,
129 }
130 }
131}
132
133impl<'a, S> GetActorSubscriptionsBuilder<'a, S>
134where
135 S: get_actor_subscriptions_state::State,
136 S::Actor: get_actor_subscriptions_state::IsUnset,
137{
138 pub fn actor(
140 mut self,
141 value: impl Into<AtIdentifier<'a>>,
142 ) -> GetActorSubscriptionsBuilder<'a, get_actor_subscriptions_state::SetActor<S>> {
143 self._fields.0 = Option::Some(value.into());
144 GetActorSubscriptionsBuilder {
145 _state: PhantomData,
146 _fields: self._fields,
147 _lifetime: PhantomData,
148 }
149 }
150}
151
152impl<'a, S: get_actor_subscriptions_state::State> GetActorSubscriptionsBuilder<'a, S> {
153 pub fn cursor(mut self, value: impl Into<Option<CowStr<'a>>>) -> Self {
155 self._fields.1 = value.into();
156 self
157 }
158 pub fn maybe_cursor(mut self, value: Option<CowStr<'a>>) -> Self {
160 self._fields.1 = value;
161 self
162 }
163}
164
165impl<'a, S: get_actor_subscriptions_state::State> GetActorSubscriptionsBuilder<'a, S> {
166 pub fn limit(mut self, value: impl Into<Option<i64>>) -> Self {
168 self._fields.2 = value.into();
169 self
170 }
171 pub fn maybe_limit(mut self, value: Option<i64>) -> Self {
173 self._fields.2 = value;
174 self
175 }
176}
177
178impl<'a, S> GetActorSubscriptionsBuilder<'a, S>
179where
180 S: get_actor_subscriptions_state::State,
181 S::Actor: get_actor_subscriptions_state::IsSet,
182{
183 pub fn build(self) -> GetActorSubscriptions<'a> {
185 GetActorSubscriptions {
186 actor: self._fields.0.unwrap(),
187 cursor: self._fields.1,
188 limit: self._fields.2,
189 }
190 }
191}