forked from
nonbinary.computer/jacquard
A better Rust ATProto crate
further codegen improvements, beginnings of xrpc client impl
+11422
-852
+2
-1
.claude/settings.local.json
+2
-1
.claude/settings.local.json
+19
-8
CLAUDE.md
+19
-8
CLAUDE.md
···
117
117
- Adds header comments with `@generated` marker and lexicon NSID
118
118
- Handles XRPC queries, procedures, subscriptions, and errors
119
119
- Generates proper module tree with Rust 2018 style
120
+
- **XrpcRequest trait**: Implemented directly on params/input structs (not marker types), with GATs for Output<'de> and Err<'de>
121
+
- **IntoStatic trait**: All generated types implement `IntoStatic` to convert borrowed types to owned ('static) variants
122
+
- **Collection trait**: Implemented on record types directly, with const NSID
120
123
121
124
## Current State & Next Steps
122
125
···
128
131
- ✅ CidLink wrapper type with automatic `{"$link": "cid"}` serialization in JSON
129
132
- ✅ Integration test with real Bluesky thread data validates round-trip correctness
130
133
- ✅ Lexicon code generation with forward compatibility and proper lifetime handling
134
+
- ✅ IntoStatic implementations for all generated types (structs, enums, unions)
135
+
- ✅ XrpcRequest trait with GATs, implemented on params/input types directly
136
+
- ✅ HttpClient and XrpcClient traits with generic send_xrpc implementation
137
+
- ✅ Response wrapper with parse() (borrowed) and into_output() (owned) methods
138
+
- ✅ Structured error types (ClientError, TransportError, EncodeError, DecodeError, HttpError, AuthError)
131
139
132
140
### Next Steps
133
-
1. **Lexicon Resolution**: Fetch lexicons from web sources (atproto authorities, git repositories) and parse into corpus
134
-
2. **Custom Lexicon Support**: Allow users to plug in their own generated lexicons alongside jacquard-api types in the client/server layer
135
-
3. **Client Implementation**: Build HTTP client layer for XRPC operations in the main `jacquard` crate
136
-
4. **Public API**: Design the main API surface in `jacquard` that re-exports and wraps generated types
137
-
5. **DID Document Support**: Parsing, validation, and resolution of DID documents
138
-
6. **OAuth Implementation**: OAuth flow support for authentication
139
-
7. **Examples & Documentation**: Create examples and improve documentation
140
-
8. **Testing**: Comprehensive tests for generated code and round-trip serialization
141
+
1. **Concrete HttpClient Implementation**: Implement HttpClient for reqwest::Client and potentially other HTTP clients
142
+
2. **Error Handling Improvements**: Add XRPC error parsing, better HTTP status code handling, structured error responses
143
+
3. **Authentication**: Session management, token refresh, DPoP support
144
+
4. **Body Encoding**: Support for non-JSON encodings (CBOR, multipart, etc.) in procedures
145
+
5. **Lexicon Resolution**: Fetch lexicons from web sources (atproto authorities, git repositories) and parse into corpus
146
+
6. **Custom Lexicon Support**: Allow users to plug in their own generated lexicons alongside jacquard-api types in the client/server layer
147
+
7. **Public API**: Design the main API surface in `jacquard` that re-exports and wraps generated types
148
+
8. **DID Document Support**: Parsing, validation, and resolution of DID documents
149
+
9. **OAuth Implementation**: OAuth flow support for authentication
150
+
10. **Examples & Documentation**: Create examples and improve documentation
151
+
11. **Testing**: Comprehensive tests for generated code and round-trip serialization
+148
-2
Cargo.lock
+148
-2
Cargo.lock
···
151
151
]
152
152
153
153
[[package]]
154
+
name = "backtrace-ext"
155
+
version = "0.2.1"
156
+
source = "registry+https://github.com/rust-lang/crates.io-index"
157
+
checksum = "537beee3be4a18fb023b570f80e3ae28003db9167a751266b259926e25539d50"
158
+
dependencies = [
159
+
"backtrace",
160
+
]
161
+
162
+
[[package]]
154
163
name = "base-x"
155
164
version = "0.2.11"
156
165
source = "registry+https://github.com/rust-lang/crates.io-index"
···
221
230
version = "1.10.1"
222
231
source = "registry+https://github.com/rust-lang/crates.io-index"
223
232
checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a"
233
+
dependencies = [
234
+
"serde",
235
+
]
236
+
237
+
[[package]]
238
+
name = "cbor4ii"
239
+
version = "0.2.14"
240
+
source = "registry+https://github.com/rust-lang/crates.io-index"
241
+
checksum = "b544cf8c89359205f4f990d0e6f3828db42df85b5dac95d09157a250eb0749c4"
224
242
dependencies = [
225
243
"serde",
226
244
]
···
563
581
version = "1.0.2"
564
582
source = "registry+https://github.com/rust-lang/crates.io-index"
565
583
checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
584
+
585
+
[[package]]
586
+
name = "errno"
587
+
version = "0.3.14"
588
+
source = "registry+https://github.com/rust-lang/crates.io-index"
589
+
checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
590
+
dependencies = [
591
+
"libc",
592
+
"windows-sys 0.52.0",
593
+
]
566
594
567
595
[[package]]
568
596
name = "find-msvc-tools"
···
1052
1080
]
1053
1081
1054
1082
[[package]]
1083
+
name = "is_ci"
1084
+
version = "1.2.0"
1085
+
source = "registry+https://github.com/rust-lang/crates.io-index"
1086
+
checksum = "7655c9839580ee829dfacba1d1278c2b7883e50a277ff7541299489d6bdfdc45"
1087
+
1088
+
[[package]]
1055
1089
name = "is_terminal_polyfill"
1056
1090
version = "1.70.1"
1057
1091
source = "registry+https://github.com/rust-lang/crates.io-index"
···
1076
1110
name = "jacquard"
1077
1111
version = "0.1.0"
1078
1112
dependencies = [
1113
+
"bytes",
1079
1114
"clap",
1115
+
"http",
1080
1116
"jacquard-api",
1081
1117
"jacquard-common",
1118
+
"miette",
1082
1119
"reqwest",
1120
+
"serde",
1121
+
"serde_html_form",
1122
+
"serde_ipld_dagcbor",
1123
+
"serde_json",
1124
+
"thiserror 2.0.17",
1083
1125
]
1084
1126
1085
1127
[[package]]
···
1186
1228
checksum = "58f929b4d672ea937a23a1ab494143d968337a5f47e56d0815df1e0890ddf174"
1187
1229
1188
1230
[[package]]
1231
+
name = "linux-raw-sys"
1232
+
version = "0.11.0"
1233
+
source = "registry+https://github.com/rust-lang/crates.io-index"
1234
+
checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039"
1235
+
1236
+
[[package]]
1189
1237
name = "litemap"
1190
1238
version = "0.8.0"
1191
1239
source = "registry+https://github.com/rust-lang/crates.io-index"
···
1215
1263
source = "registry+https://github.com/rust-lang/crates.io-index"
1216
1264
checksum = "5f98efec8807c63c752b5bd61f862c165c115b0a35685bdcfd9238c7aeb592b7"
1217
1265
dependencies = [
1266
+
"backtrace",
1267
+
"backtrace-ext",
1218
1268
"cfg-if",
1219
1269
"miette-derive",
1220
-
"unicode-width",
1270
+
"owo-colors",
1271
+
"supports-color",
1272
+
"supports-hyperlinks",
1273
+
"supports-unicode",
1274
+
"terminal_size",
1275
+
"textwrap",
1276
+
"unicode-width 0.1.14",
1221
1277
]
1222
1278
1223
1279
[[package]]
···
1354
1410
"quote",
1355
1411
"syn 2.0.106",
1356
1412
]
1413
+
1414
+
[[package]]
1415
+
name = "owo-colors"
1416
+
version = "4.2.2"
1417
+
source = "registry+https://github.com/rust-lang/crates.io-index"
1418
+
checksum = "48dd4f4a2c8405440fd0462561f0e5806bd0f77e86f51c761481bdd4018b545e"
1357
1419
1358
1420
[[package]]
1359
1421
name = "percent-encoding"
···
1505
1567
"once_cell",
1506
1568
"socket2",
1507
1569
"tracing",
1508
-
"windows-sys 0.52.0",
1570
+
"windows-sys 0.60.2",
1509
1571
]
1510
1572
1511
1573
[[package]]
···
1678
1740
checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
1679
1741
1680
1742
[[package]]
1743
+
name = "rustix"
1744
+
version = "1.1.2"
1745
+
source = "registry+https://github.com/rust-lang/crates.io-index"
1746
+
checksum = "cd15f8a2c5551a84d56efdc1cd049089e409ac19a3072d5037a17fd70719ff3e"
1747
+
dependencies = [
1748
+
"bitflags",
1749
+
"errno",
1750
+
"libc",
1751
+
"linux-raw-sys",
1752
+
"windows-sys 0.52.0",
1753
+
]
1754
+
1755
+
[[package]]
1681
1756
name = "rustls"
1682
1757
version = "0.23.32"
1683
1758
source = "registry+https://github.com/rust-lang/crates.io-index"
···
1749
1824
]
1750
1825
1751
1826
[[package]]
1827
+
name = "scopeguard"
1828
+
version = "1.2.0"
1829
+
source = "registry+https://github.com/rust-lang/crates.io-index"
1830
+
checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
1831
+
1832
+
[[package]]
1752
1833
name = "serde"
1753
1834
version = "1.0.228"
1754
1835
source = "registry+https://github.com/rust-lang/crates.io-index"
···
1798
1879
"itoa",
1799
1880
"ryu",
1800
1881
"serde_core",
1882
+
]
1883
+
1884
+
[[package]]
1885
+
name = "serde_ipld_dagcbor"
1886
+
version = "0.6.4"
1887
+
source = "registry+https://github.com/rust-lang/crates.io-index"
1888
+
checksum = "46182f4f08349a02b45c998ba3215d3f9de826246ba02bb9dddfe9a2a2100778"
1889
+
dependencies = [
1890
+
"cbor4ii",
1891
+
"ipld-core",
1892
+
"scopeguard",
1893
+
"serde",
1801
1894
]
1802
1895
1803
1896
[[package]]
···
1962
2055
checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
1963
2056
1964
2057
[[package]]
2058
+
name = "supports-color"
2059
+
version = "3.0.2"
2060
+
source = "registry+https://github.com/rust-lang/crates.io-index"
2061
+
checksum = "c64fc7232dd8d2e4ac5ce4ef302b1d81e0b80d055b9d77c7c4f51f6aa4c867d6"
2062
+
dependencies = [
2063
+
"is_ci",
2064
+
]
2065
+
2066
+
[[package]]
2067
+
name = "supports-hyperlinks"
2068
+
version = "3.1.0"
2069
+
source = "registry+https://github.com/rust-lang/crates.io-index"
2070
+
checksum = "804f44ed3c63152de6a9f90acbea1a110441de43006ea51bcce8f436196a288b"
2071
+
2072
+
[[package]]
2073
+
name = "supports-unicode"
2074
+
version = "3.0.0"
2075
+
source = "registry+https://github.com/rust-lang/crates.io-index"
2076
+
checksum = "b7401a30af6cb5818bb64852270bb722533397edcfc7344954a38f420819ece2"
2077
+
2078
+
[[package]]
1965
2079
name = "syn"
1966
2080
version = "1.0.109"
1967
2081
source = "registry+https://github.com/rust-lang/crates.io-index"
···
2021
2135
dependencies = [
2022
2136
"core-foundation-sys",
2023
2137
"libc",
2138
+
]
2139
+
2140
+
[[package]]
2141
+
name = "terminal_size"
2142
+
version = "0.4.3"
2143
+
source = "registry+https://github.com/rust-lang/crates.io-index"
2144
+
checksum = "60b8cb979cb11c32ce1603f8137b22262a9d131aaa5c37b5678025f22b8becd0"
2145
+
dependencies = [
2146
+
"rustix",
2147
+
"windows-sys 0.60.2",
2148
+
]
2149
+
2150
+
[[package]]
2151
+
name = "textwrap"
2152
+
version = "0.16.2"
2153
+
source = "registry+https://github.com/rust-lang/crates.io-index"
2154
+
checksum = "c13547615a44dc9c452a8a534638acdf07120d4b6847c8178705da06306a3057"
2155
+
dependencies = [
2156
+
"unicode-linebreak",
2157
+
"unicode-width 0.2.1",
2024
2158
]
2025
2159
2026
2160
[[package]]
···
2242
2376
checksum = "f63a545481291138910575129486daeaf8ac54aee4387fe7906919f7830c7d9d"
2243
2377
2244
2378
[[package]]
2379
+
name = "unicode-linebreak"
2380
+
version = "0.1.5"
2381
+
source = "registry+https://github.com/rust-lang/crates.io-index"
2382
+
checksum = "3b09c83c3c29d37506a3e260c08c03743a6bb66a9cd432c6934ab501a190571f"
2383
+
2384
+
[[package]]
2245
2385
name = "unicode-width"
2246
2386
version = "0.1.14"
2247
2387
source = "registry+https://github.com/rust-lang/crates.io-index"
2248
2388
checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"
2389
+
2390
+
[[package]]
2391
+
name = "unicode-width"
2392
+
version = "0.2.1"
2393
+
source = "registry+https://github.com/rust-lang/crates.io-index"
2394
+
checksum = "4a1a07cc7db3810833284e8d372ccdc6da29741639ecc70c9ec107df0fa6154c"
2249
2395
2250
2396
[[package]]
2251
2397
name = "unsigned-varint"
+412
crates/jacquard-api/src/app_bsky/actor.rs
+412
crates/jacquard-api/src/app_bsky/actor.rs
···
22
22
pub enabled: bool,
23
23
}
24
24
25
+
impl jacquard_common::IntoStatic for AdultContentPref<'_> {
26
+
type Output = AdultContentPref<'static>;
27
+
fn into_static(self) -> Self::Output {
28
+
AdultContentPref {
29
+
enabled: self.enabled.into_static(),
30
+
extra_data: self.extra_data.into_static(),
31
+
}
32
+
}
33
+
}
34
+
25
35
///If set, an active progress guide. Once completed, can be set to undefined. Should have unspecced fields tracking progress.
26
36
#[jacquard_derive::lexicon]
27
37
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
31
41
pub guide: jacquard_common::CowStr<'a>,
32
42
}
33
43
44
+
impl jacquard_common::IntoStatic for BskyAppProgressGuide<'_> {
45
+
type Output = BskyAppProgressGuide<'static>;
46
+
fn into_static(self) -> Self::Output {
47
+
BskyAppProgressGuide {
48
+
guide: self.guide.into_static(),
49
+
extra_data: self.extra_data.into_static(),
50
+
}
51
+
}
52
+
}
53
+
34
54
///A grab bag of state that's specific to the bsky.app program. Third-party apps shouldn't use this.
35
55
#[jacquard_derive::lexicon]
36
56
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
51
71
pub queued_nudges: std::option::Option<Vec<jacquard_common::CowStr<'a>>>,
52
72
}
53
73
74
+
impl jacquard_common::IntoStatic for BskyAppStatePref<'_> {
75
+
type Output = BskyAppStatePref<'static>;
76
+
fn into_static(self) -> Self::Output {
77
+
BskyAppStatePref {
78
+
active_progress_guide: self.active_progress_guide.into_static(),
79
+
nuxs: self.nuxs.into_static(),
80
+
queued_nudges: self.queued_nudges.into_static(),
81
+
extra_data: self.extra_data.into_static(),
82
+
}
83
+
}
84
+
}
85
+
54
86
#[jacquard_derive::lexicon]
55
87
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
56
88
#[serde(rename_all = "camelCase")]
···
65
97
pub visibility: jacquard_common::CowStr<'a>,
66
98
}
67
99
100
+
impl jacquard_common::IntoStatic for ContentLabelPref<'_> {
101
+
type Output = ContentLabelPref<'static>;
102
+
fn into_static(self) -> Self::Output {
103
+
ContentLabelPref {
104
+
label: self.label.into_static(),
105
+
labeler_did: self.labeler_did.into_static(),
106
+
visibility: self.visibility.into_static(),
107
+
extra_data: self.extra_data.into_static(),
108
+
}
109
+
}
110
+
}
111
+
68
112
#[jacquard_derive::lexicon]
69
113
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
70
114
#[serde(rename_all = "camelCase")]
···
89
133
pub hide_reposts: std::option::Option<bool>,
90
134
}
91
135
136
+
impl jacquard_common::IntoStatic for FeedViewPref<'_> {
137
+
type Output = FeedViewPref<'static>;
138
+
fn into_static(self) -> Self::Output {
139
+
FeedViewPref {
140
+
feed: self.feed.into_static(),
141
+
hide_quote_posts: self.hide_quote_posts.into_static(),
142
+
hide_replies: self.hide_replies.into_static(),
143
+
hide_replies_by_like_count: self.hide_replies_by_like_count.into_static(),
144
+
hide_replies_by_unfollowed: self.hide_replies_by_unfollowed.into_static(),
145
+
hide_reposts: self.hide_reposts.into_static(),
146
+
extra_data: self.extra_data.into_static(),
147
+
}
148
+
}
149
+
}
150
+
92
151
#[jacquard_derive::lexicon]
93
152
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
94
153
#[serde(rename_all = "camelCase")]
···
98
157
pub items: Vec<jacquard_common::types::string::AtUri<'a>>,
99
158
}
100
159
160
+
impl jacquard_common::IntoStatic for HiddenPostsPref<'_> {
161
+
type Output = HiddenPostsPref<'static>;
162
+
fn into_static(self) -> Self::Output {
163
+
HiddenPostsPref {
164
+
items: self.items.into_static(),
165
+
extra_data: self.extra_data.into_static(),
166
+
}
167
+
}
168
+
}
169
+
101
170
#[jacquard_derive::lexicon]
102
171
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
103
172
#[serde(rename_all = "camelCase")]
···
107
176
pub tags: Vec<jacquard_common::CowStr<'a>>,
108
177
}
109
178
179
+
impl jacquard_common::IntoStatic for InterestsPref<'_> {
180
+
type Output = InterestsPref<'static>;
181
+
fn into_static(self) -> Self::Output {
182
+
InterestsPref {
183
+
tags: self.tags.into_static(),
184
+
extra_data: self.extra_data.into_static(),
185
+
}
186
+
}
187
+
}
188
+
110
189
///The subject's followers whom you also follow
111
190
#[jacquard_derive::lexicon]
112
191
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
117
196
pub followers: Vec<crate::app_bsky::actor::ProfileViewBasic<'a>>,
118
197
}
119
198
199
+
impl jacquard_common::IntoStatic for KnownFollowers<'_> {
200
+
type Output = KnownFollowers<'static>;
201
+
fn into_static(self) -> Self::Output {
202
+
KnownFollowers {
203
+
count: self.count.into_static(),
204
+
followers: self.followers.into_static(),
205
+
extra_data: self.extra_data.into_static(),
206
+
}
207
+
}
208
+
}
209
+
120
210
#[jacquard_derive::lexicon]
121
211
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
122
212
#[serde(rename_all = "camelCase")]
···
125
215
pub did: jacquard_common::types::string::Did<'a>,
126
216
}
127
217
218
+
impl jacquard_common::IntoStatic for LabelerPrefItem<'_> {
219
+
type Output = LabelerPrefItem<'static>;
220
+
fn into_static(self) -> Self::Output {
221
+
LabelerPrefItem {
222
+
did: self.did.into_static(),
223
+
extra_data: self.extra_data.into_static(),
224
+
}
225
+
}
226
+
}
227
+
128
228
#[jacquard_derive::lexicon]
129
229
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
130
230
#[serde(rename_all = "camelCase")]
···
133
233
pub labelers: Vec<crate::app_bsky::actor::LabelerPrefItem<'a>>,
134
234
}
135
235
236
+
impl jacquard_common::IntoStatic for LabelersPref<'_> {
237
+
type Output = LabelersPref<'static>;
238
+
fn into_static(self) -> Self::Output {
239
+
LabelersPref {
240
+
labelers: self.labelers.into_static(),
241
+
extra_data: self.extra_data.into_static(),
242
+
}
243
+
}
244
+
}
245
+
136
246
///A word that the account owner has muted.
137
247
#[jacquard_derive::lexicon]
138
248
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
154
264
///The muted word itself.
155
265
#[serde(borrow)]
156
266
pub value: jacquard_common::CowStr<'a>,
267
+
}
268
+
269
+
impl jacquard_common::IntoStatic for MutedWord<'_> {
270
+
type Output = MutedWord<'static>;
271
+
fn into_static(self) -> Self::Output {
272
+
MutedWord {
273
+
actor_target: self.actor_target.into_static(),
274
+
expires_at: self.expires_at.into_static(),
275
+
id: self.id.into_static(),
276
+
targets: self.targets.into_static(),
277
+
value: self.value.into_static(),
278
+
extra_data: self.extra_data.into_static(),
279
+
}
280
+
}
157
281
}
158
282
159
283
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
···
221
345
}
222
346
}
223
347
348
+
impl jacquard_common::IntoStatic for MutedWordTarget<'_> {
349
+
type Output = MutedWordTarget<'static>;
350
+
fn into_static(self) -> Self::Output {
351
+
match self {
352
+
MutedWordTarget::Content => MutedWordTarget::Content,
353
+
MutedWordTarget::Tag => MutedWordTarget::Tag,
354
+
MutedWordTarget::Other(v) => MutedWordTarget::Other(v.into_static()),
355
+
}
356
+
}
357
+
}
358
+
224
359
#[jacquard_derive::lexicon]
225
360
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
226
361
#[serde(rename_all = "camelCase")]
···
230
365
pub items: Vec<crate::app_bsky::actor::MutedWord<'a>>,
231
366
}
232
367
368
+
impl jacquard_common::IntoStatic for MutedWordsPref<'_> {
369
+
type Output = MutedWordsPref<'static>;
370
+
fn into_static(self) -> Self::Output {
371
+
MutedWordsPref {
372
+
items: self.items.into_static(),
373
+
extra_data: self.extra_data.into_static(),
374
+
}
375
+
}
376
+
}
377
+
233
378
///A new user experiences (NUX) storage object
234
379
#[jacquard_derive::lexicon]
235
380
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
247
392
pub id: jacquard_common::CowStr<'a>,
248
393
}
249
394
395
+
impl jacquard_common::IntoStatic for Nux<'_> {
396
+
type Output = Nux<'static>;
397
+
fn into_static(self) -> Self::Output {
398
+
Nux {
399
+
completed: self.completed.into_static(),
400
+
data: self.data.into_static(),
401
+
expires_at: self.expires_at.into_static(),
402
+
id: self.id.into_static(),
403
+
extra_data: self.extra_data.into_static(),
404
+
}
405
+
}
406
+
}
407
+
250
408
#[jacquard_derive::lexicon]
251
409
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
252
410
#[serde(rename_all = "camelCase")]
···
254
412
///The birth date of account owner.
255
413
#[serde(skip_serializing_if = "std::option::Option::is_none")]
256
414
pub birth_date: std::option::Option<jacquard_common::types::string::Datetime>,
415
+
}
416
+
417
+
impl jacquard_common::IntoStatic for PersonalDetailsPref<'_> {
418
+
type Output = PersonalDetailsPref<'static>;
419
+
fn into_static(self) -> Self::Output {
420
+
PersonalDetailsPref {
421
+
birth_date: self.birth_date.into_static(),
422
+
extra_data: self.extra_data.into_static(),
423
+
}
424
+
}
257
425
}
258
426
259
427
///Default post interaction settings for the account. These values should be applied as default values when creating new posts. These refs should mirror the threadgate and postgate records exactly.
···
275
443
>,
276
444
}
277
445
446
+
impl jacquard_common::IntoStatic for PostInteractionSettingsPref<'_> {
447
+
type Output = PostInteractionSettingsPref<'static>;
448
+
fn into_static(self) -> Self::Output {
449
+
PostInteractionSettingsPref {
450
+
postgate_embedding_rules: self.postgate_embedding_rules.into_static(),
451
+
threadgate_allow_rules: self.threadgate_allow_rules.into_static(),
452
+
extra_data: self.extra_data.into_static(),
453
+
}
454
+
}
455
+
}
456
+
278
457
pub type Preferences<'a> = Vec<jacquard_common::types::value::Data<'a>>;
279
458
#[jacquard_derive::lexicon]
280
459
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
298
477
pub starter_packs: std::option::Option<i64>,
299
478
}
300
479
480
+
impl jacquard_common::IntoStatic for ProfileAssociated<'_> {
481
+
type Output = ProfileAssociated<'static>;
482
+
fn into_static(self) -> Self::Output {
483
+
ProfileAssociated {
484
+
activity_subscription: self.activity_subscription.into_static(),
485
+
chat: self.chat.into_static(),
486
+
feedgens: self.feedgens.into_static(),
487
+
labeler: self.labeler.into_static(),
488
+
lists: self.lists.into_static(),
489
+
starter_packs: self.starter_packs.into_static(),
490
+
extra_data: self.extra_data.into_static(),
491
+
}
492
+
}
493
+
}
494
+
301
495
#[jacquard_derive::lexicon]
302
496
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
303
497
#[serde(rename_all = "camelCase")]
···
306
500
pub allow_subscriptions: jacquard_common::CowStr<'a>,
307
501
}
308
502
503
+
impl jacquard_common::IntoStatic for ProfileAssociatedActivitySubscription<'_> {
504
+
type Output = ProfileAssociatedActivitySubscription<'static>;
505
+
fn into_static(self) -> Self::Output {
506
+
ProfileAssociatedActivitySubscription {
507
+
allow_subscriptions: self.allow_subscriptions.into_static(),
508
+
extra_data: self.extra_data.into_static(),
509
+
}
510
+
}
511
+
}
512
+
309
513
#[jacquard_derive::lexicon]
310
514
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
311
515
#[serde(rename_all = "camelCase")]
···
314
518
pub allow_incoming: jacquard_common::CowStr<'a>,
315
519
}
316
520
521
+
impl jacquard_common::IntoStatic for ProfileAssociatedChat<'_> {
522
+
type Output = ProfileAssociatedChat<'static>;
523
+
fn into_static(self) -> Self::Output {
524
+
ProfileAssociatedChat {
525
+
allow_incoming: self.allow_incoming.into_static(),
526
+
extra_data: self.extra_data.into_static(),
527
+
}
528
+
}
529
+
}
530
+
317
531
#[jacquard_derive::lexicon]
318
532
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
319
533
#[serde(rename_all = "camelCase")]
···
355
569
pub viewer: std::option::Option<crate::app_bsky::actor::ViewerState<'a>>,
356
570
}
357
571
572
+
impl jacquard_common::IntoStatic for ProfileView<'_> {
573
+
type Output = ProfileView<'static>;
574
+
fn into_static(self) -> Self::Output {
575
+
ProfileView {
576
+
associated: self.associated.into_static(),
577
+
avatar: self.avatar.into_static(),
578
+
created_at: self.created_at.into_static(),
579
+
description: self.description.into_static(),
580
+
did: self.did.into_static(),
581
+
display_name: self.display_name.into_static(),
582
+
handle: self.handle.into_static(),
583
+
indexed_at: self.indexed_at.into_static(),
584
+
labels: self.labels.into_static(),
585
+
pronouns: self.pronouns.into_static(),
586
+
status: self.status.into_static(),
587
+
verification: self.verification.into_static(),
588
+
viewer: self.viewer.into_static(),
589
+
extra_data: self.extra_data.into_static(),
590
+
}
591
+
}
592
+
}
593
+
358
594
#[jacquard_derive::lexicon]
359
595
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
360
596
#[serde(rename_all = "camelCase")]
···
389
625
#[serde(skip_serializing_if = "std::option::Option::is_none")]
390
626
#[serde(borrow)]
391
627
pub viewer: std::option::Option<crate::app_bsky::actor::ViewerState<'a>>,
628
+
}
629
+
630
+
impl jacquard_common::IntoStatic for ProfileViewBasic<'_> {
631
+
type Output = ProfileViewBasic<'static>;
632
+
fn into_static(self) -> Self::Output {
633
+
ProfileViewBasic {
634
+
associated: self.associated.into_static(),
635
+
avatar: self.avatar.into_static(),
636
+
created_at: self.created_at.into_static(),
637
+
did: self.did.into_static(),
638
+
display_name: self.display_name.into_static(),
639
+
handle: self.handle.into_static(),
640
+
labels: self.labels.into_static(),
641
+
pronouns: self.pronouns.into_static(),
642
+
status: self.status.into_static(),
643
+
verification: self.verification.into_static(),
644
+
viewer: self.viewer.into_static(),
645
+
extra_data: self.extra_data.into_static(),
646
+
}
647
+
}
392
648
}
393
649
394
650
#[jacquard_derive::lexicon]
···
454
710
pub website: std::option::Option<jacquard_common::types::string::Uri<'a>>,
455
711
}
456
712
713
+
impl jacquard_common::IntoStatic for ProfileViewDetailed<'_> {
714
+
type Output = ProfileViewDetailed<'static>;
715
+
fn into_static(self) -> Self::Output {
716
+
ProfileViewDetailed {
717
+
associated: self.associated.into_static(),
718
+
avatar: self.avatar.into_static(),
719
+
banner: self.banner.into_static(),
720
+
created_at: self.created_at.into_static(),
721
+
description: self.description.into_static(),
722
+
did: self.did.into_static(),
723
+
display_name: self.display_name.into_static(),
724
+
followers_count: self.followers_count.into_static(),
725
+
follows_count: self.follows_count.into_static(),
726
+
handle: self.handle.into_static(),
727
+
indexed_at: self.indexed_at.into_static(),
728
+
joined_via_starter_pack: self.joined_via_starter_pack.into_static(),
729
+
labels: self.labels.into_static(),
730
+
pinned_post: self.pinned_post.into_static(),
731
+
posts_count: self.posts_count.into_static(),
732
+
pronouns: self.pronouns.into_static(),
733
+
status: self.status.into_static(),
734
+
verification: self.verification.into_static(),
735
+
viewer: self.viewer.into_static(),
736
+
website: self.website.into_static(),
737
+
extra_data: self.extra_data.into_static(),
738
+
}
739
+
}
740
+
}
741
+
457
742
#[jacquard_derive::lexicon]
458
743
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
459
744
#[serde(rename_all = "camelCase")]
···
467
752
pub value: jacquard_common::CowStr<'a>,
468
753
}
469
754
755
+
impl jacquard_common::IntoStatic for SavedFeed<'_> {
756
+
type Output = SavedFeed<'static>;
757
+
fn into_static(self) -> Self::Output {
758
+
SavedFeed {
759
+
id: self.id.into_static(),
760
+
pinned: self.pinned.into_static(),
761
+
r#type: self.r#type.into_static(),
762
+
value: self.value.into_static(),
763
+
extra_data: self.extra_data.into_static(),
764
+
}
765
+
}
766
+
}
767
+
470
768
#[jacquard_derive::lexicon]
471
769
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
472
770
#[serde(rename_all = "camelCase")]
···
479
777
pub timeline_index: std::option::Option<i64>,
480
778
}
481
779
780
+
impl jacquard_common::IntoStatic for SavedFeedsPref<'_> {
781
+
type Output = SavedFeedsPref<'static>;
782
+
fn into_static(self) -> Self::Output {
783
+
SavedFeedsPref {
784
+
pinned: self.pinned.into_static(),
785
+
saved: self.saved.into_static(),
786
+
timeline_index: self.timeline_index.into_static(),
787
+
extra_data: self.extra_data.into_static(),
788
+
}
789
+
}
790
+
}
791
+
482
792
#[jacquard_derive::lexicon]
483
793
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
484
794
#[serde(rename_all = "camelCase")]
485
795
pub struct SavedFeedsPrefV2<'a> {
486
796
#[serde(borrow)]
487
797
pub items: Vec<crate::app_bsky::actor::SavedFeed<'a>>,
798
+
}
799
+
800
+
impl jacquard_common::IntoStatic for SavedFeedsPrefV2<'_> {
801
+
type Output = SavedFeedsPrefV2<'static>;
802
+
fn into_static(self) -> Self::Output {
803
+
SavedFeedsPrefV2 {
804
+
items: self.items.into_static(),
805
+
extra_data: self.extra_data.into_static(),
806
+
}
807
+
}
488
808
}
489
809
490
810
#[jacquard_derive::lexicon]
···
517
837
ExternalView(Box<crate::app_bsky::embed::external::View<'a>>),
518
838
}
519
839
840
+
impl jacquard_common::IntoStatic for StatusViewRecordEmbed<'_> {
841
+
type Output = StatusViewRecordEmbed<'static>;
842
+
fn into_static(self) -> Self::Output {
843
+
match self {
844
+
StatusViewRecordEmbed::ExternalView(v) => {
845
+
StatusViewRecordEmbed::ExternalView(v.into_static())
846
+
}
847
+
StatusViewRecordEmbed::Unknown(v) => {
848
+
StatusViewRecordEmbed::Unknown(v.into_static())
849
+
}
850
+
}
851
+
}
852
+
}
853
+
854
+
impl jacquard_common::IntoStatic for StatusView<'_> {
855
+
type Output = StatusView<'static>;
856
+
fn into_static(self) -> Self::Output {
857
+
StatusView {
858
+
embed: self.embed.into_static(),
859
+
expires_at: self.expires_at.into_static(),
860
+
is_active: self.is_active.into_static(),
861
+
record: self.record.into_static(),
862
+
status: self.status.into_static(),
863
+
extra_data: self.extra_data.into_static(),
864
+
}
865
+
}
866
+
}
867
+
520
868
#[jacquard_derive::lexicon]
521
869
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
522
870
#[serde(rename_all = "camelCase")]
···
530
878
pub sort: std::option::Option<jacquard_common::CowStr<'a>>,
531
879
}
532
880
881
+
impl jacquard_common::IntoStatic for ThreadViewPref<'_> {
882
+
type Output = ThreadViewPref<'static>;
883
+
fn into_static(self) -> Self::Output {
884
+
ThreadViewPref {
885
+
prioritize_followed_users: self.prioritize_followed_users.into_static(),
886
+
sort: self.sort.into_static(),
887
+
extra_data: self.extra_data.into_static(),
888
+
}
889
+
}
890
+
}
891
+
533
892
///Preferences for how verified accounts appear in the app.
534
893
#[jacquard_derive::lexicon]
535
894
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
540
899
pub hide_badges: std::option::Option<bool>,
541
900
}
542
901
902
+
impl jacquard_common::IntoStatic for VerificationPrefs<'_> {
903
+
type Output = VerificationPrefs<'static>;
904
+
fn into_static(self) -> Self::Output {
905
+
VerificationPrefs {
906
+
hide_badges: self.hide_badges.into_static(),
907
+
extra_data: self.extra_data.into_static(),
908
+
}
909
+
}
910
+
}
911
+
543
912
///Represents the verification information about the user this object is attached to.
544
913
#[jacquard_derive::lexicon]
545
914
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
556
925
pub verified_status: jacquard_common::CowStr<'a>,
557
926
}
558
927
928
+
impl jacquard_common::IntoStatic for VerificationState<'_> {
929
+
type Output = VerificationState<'static>;
930
+
fn into_static(self) -> Self::Output {
931
+
VerificationState {
932
+
trusted_verifier_status: self.trusted_verifier_status.into_static(),
933
+
verifications: self.verifications.into_static(),
934
+
verified_status: self.verified_status.into_static(),
935
+
extra_data: self.extra_data.into_static(),
936
+
}
937
+
}
938
+
}
939
+
559
940
///An individual verification for an associated subject.
560
941
#[jacquard_derive::lexicon]
561
942
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
573
954
pub uri: jacquard_common::types::string::AtUri<'a>,
574
955
}
575
956
957
+
impl jacquard_common::IntoStatic for VerificationView<'_> {
958
+
type Output = VerificationView<'static>;
959
+
fn into_static(self) -> Self::Output {
960
+
VerificationView {
961
+
created_at: self.created_at.into_static(),
962
+
is_valid: self.is_valid.into_static(),
963
+
issuer: self.issuer.into_static(),
964
+
uri: self.uri.into_static(),
965
+
extra_data: self.extra_data.into_static(),
966
+
}
967
+
}
968
+
}
969
+
576
970
///Metadata about the requesting account's relationship with the subject account. Only has meaningful content for authed requests.
577
971
#[jacquard_derive::lexicon]
578
972
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
607
1001
#[serde(skip_serializing_if = "std::option::Option::is_none")]
608
1002
#[serde(borrow)]
609
1003
pub muted_by_list: std::option::Option<crate::app_bsky::graph::ListViewBasic<'a>>,
1004
+
}
1005
+
1006
+
impl jacquard_common::IntoStatic for ViewerState<'_> {
1007
+
type Output = ViewerState<'static>;
1008
+
fn into_static(self) -> Self::Output {
1009
+
ViewerState {
1010
+
activity_subscription: self.activity_subscription.into_static(),
1011
+
blocked_by: self.blocked_by.into_static(),
1012
+
blocking: self.blocking.into_static(),
1013
+
blocking_by_list: self.blocking_by_list.into_static(),
1014
+
followed_by: self.followed_by.into_static(),
1015
+
following: self.following.into_static(),
1016
+
known_followers: self.known_followers.into_static(),
1017
+
muted: self.muted.into_static(),
1018
+
muted_by_list: self.muted_by_list.into_static(),
1019
+
extra_data: self.extra_data.into_static(),
1020
+
}
1021
+
}
610
1022
}
+18
-1
crates/jacquard-api/src/app_bsky/actor/get_preferences.rs
+18
-1
crates/jacquard-api/src/app_bsky/actor/get_preferences.rs
···
8
8
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetPreferences {}
11
+
impl jacquard_common::IntoStatic for GetPreferences {
12
+
type Output = GetPreferences;
13
+
fn into_static(self) -> Self::Output {
14
+
self
15
+
}
16
+
}
17
+
11
18
#[jacquard_derive::lexicon]
12
19
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
13
20
#[serde(rename_all = "camelCase")]
···
16
23
pub preferences: crate::app_bsky::actor::Preferences<'a>,
17
24
}
18
25
26
+
impl jacquard_common::IntoStatic for GetPreferencesOutput<'_> {
27
+
type Output = GetPreferencesOutput<'static>;
28
+
fn into_static(self) -> Self::Output {
29
+
GetPreferencesOutput {
30
+
preferences: self.preferences.into_static(),
31
+
extra_data: self.extra_data.into_static(),
32
+
}
33
+
}
34
+
}
35
+
19
36
impl jacquard_common::types::xrpc::XrpcRequest for GetPreferences {
20
37
const NSID: &'static str = "app.bsky.actor.getPreferences";
21
38
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
22
39
const OUTPUT_ENCODING: &'static str = "application/json";
23
40
type Output<'de> = GetPreferencesOutput<'de>;
24
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
41
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
25
42
}
+20
-1
crates/jacquard-api/src/app_bsky/actor/get_profile.rs
+20
-1
crates/jacquard-api/src/app_bsky/actor/get_profile.rs
···
12
12
pub actor: jacquard_common::types::ident::AtIdentifier<'a>,
13
13
}
14
14
15
+
impl jacquard_common::IntoStatic for GetProfile<'_> {
16
+
type Output = GetProfile<'static>;
17
+
fn into_static(self) -> Self::Output {
18
+
GetProfile {
19
+
actor: self.actor.into_static(),
20
+
}
21
+
}
22
+
}
23
+
15
24
#[jacquard_derive::lexicon]
16
25
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
26
#[serde(rename_all = "camelCase")]
···
21
30
pub value: crate::app_bsky::actor::ProfileViewDetailed<'a>,
22
31
}
23
32
33
+
impl jacquard_common::IntoStatic for GetProfileOutput<'_> {
34
+
type Output = GetProfileOutput<'static>;
35
+
fn into_static(self) -> Self::Output {
36
+
GetProfileOutput {
37
+
value: self.value.into_static(),
38
+
extra_data: self.extra_data.into_static(),
39
+
}
40
+
}
41
+
}
42
+
24
43
impl jacquard_common::types::xrpc::XrpcRequest for GetProfile<'_> {
25
44
const NSID: &'static str = "app.bsky.actor.getProfile";
26
45
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
27
46
const OUTPUT_ENCODING: &'static str = "application/json";
28
47
type Output<'de> = GetProfileOutput<'de>;
29
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
48
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
30
49
}
+20
-1
crates/jacquard-api/src/app_bsky/actor/get_profiles.rs
+20
-1
crates/jacquard-api/src/app_bsky/actor/get_profiles.rs
···
12
12
pub actors: Vec<jacquard_common::types::ident::AtIdentifier<'a>>,
13
13
}
14
14
15
+
impl jacquard_common::IntoStatic for GetProfiles<'_> {
16
+
type Output = GetProfiles<'static>;
17
+
fn into_static(self) -> Self::Output {
18
+
GetProfiles {
19
+
actors: self.actors.into_static(),
20
+
}
21
+
}
22
+
}
23
+
15
24
#[jacquard_derive::lexicon]
16
25
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
26
#[serde(rename_all = "camelCase")]
···
20
29
pub profiles: Vec<crate::app_bsky::actor::ProfileViewDetailed<'a>>,
21
30
}
22
31
32
+
impl jacquard_common::IntoStatic for GetProfilesOutput<'_> {
33
+
type Output = GetProfilesOutput<'static>;
34
+
fn into_static(self) -> Self::Output {
35
+
GetProfilesOutput {
36
+
profiles: self.profiles.into_static(),
37
+
extra_data: self.extra_data.into_static(),
38
+
}
39
+
}
40
+
}
41
+
23
42
impl jacquard_common::types::xrpc::XrpcRequest for GetProfiles<'_> {
24
43
const NSID: &'static str = "app.bsky.actor.getProfiles";
25
44
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
26
45
const OUTPUT_ENCODING: &'static str = "application/json";
27
46
type Output<'de> = GetProfilesOutput<'de>;
28
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
47
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
29
48
}
+21
-7
crates/jacquard-api/src/app_bsky/actor/get_suggestions.rs
+21
-7
crates/jacquard-api/src/app_bsky/actor/get_suggestions.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetSuggestions<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
12
#[serde(borrow)]
13
13
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
14
+
///(default: 50, min: 1, max: 100)
14
15
#[serde(skip_serializing_if = "std::option::Option::is_none")]
15
16
pub limit: std::option::Option<i64>,
16
17
}
17
18
18
-
impl Default for GetSuggestions<'_> {
19
-
fn default() -> Self {
20
-
Self {
21
-
cursor: Default::default(),
22
-
limit: Some(50i64),
19
+
impl jacquard_common::IntoStatic for GetSuggestions<'_> {
20
+
type Output = GetSuggestions<'static>;
21
+
fn into_static(self) -> Self::Output {
22
+
GetSuggestions {
23
+
cursor: self.cursor.into_static(),
24
+
limit: self.limit.into_static(),
23
25
}
24
26
}
25
27
}
···
38
40
pub rec_id: std::option::Option<i64>,
39
41
}
40
42
43
+
impl jacquard_common::IntoStatic for GetSuggestionsOutput<'_> {
44
+
type Output = GetSuggestionsOutput<'static>;
45
+
fn into_static(self) -> Self::Output {
46
+
GetSuggestionsOutput {
47
+
actors: self.actors.into_static(),
48
+
cursor: self.cursor.into_static(),
49
+
rec_id: self.rec_id.into_static(),
50
+
extra_data: self.extra_data.into_static(),
51
+
}
52
+
}
53
+
}
54
+
41
55
impl jacquard_common::types::xrpc::XrpcRequest for GetSuggestions<'_> {
42
56
const NSID: &'static str = "app.bsky.actor.getSuggestions";
43
57
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
44
58
const OUTPUT_ENCODING: &'static str = "application/json";
45
59
type Output<'de> = GetSuggestionsOutput<'de>;
46
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
60
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
47
61
}
+33
crates/jacquard-api/src/app_bsky/actor/profile.rs
+33
crates/jacquard-api/src/app_bsky/actor/profile.rs
···
59
59
DefsSelfLabels(Box<crate::com_atproto::label::SelfLabels<'a>>),
60
60
}
61
61
62
+
impl jacquard_common::IntoStatic for ProfileRecordLabels<'_> {
63
+
type Output = ProfileRecordLabels<'static>;
64
+
fn into_static(self) -> Self::Output {
65
+
match self {
66
+
ProfileRecordLabels::DefsSelfLabels(v) => {
67
+
ProfileRecordLabels::DefsSelfLabels(v.into_static())
68
+
}
69
+
ProfileRecordLabels::Unknown(v) => {
70
+
ProfileRecordLabels::Unknown(v.into_static())
71
+
}
72
+
}
73
+
}
74
+
}
75
+
62
76
impl jacquard_common::types::collection::Collection for Profile<'_> {
63
77
const NSID: &'static str = "app.bsky.actor.profile";
78
+
}
79
+
80
+
impl jacquard_common::IntoStatic for Profile<'_> {
81
+
type Output = Profile<'static>;
82
+
fn into_static(self) -> Self::Output {
83
+
Profile {
84
+
avatar: self.avatar.into_static(),
85
+
banner: self.banner.into_static(),
86
+
created_at: self.created_at.into_static(),
87
+
description: self.description.into_static(),
88
+
display_name: self.display_name.into_static(),
89
+
joined_via_starter_pack: self.joined_via_starter_pack.into_static(),
90
+
labels: self.labels.into_static(),
91
+
pinned_post: self.pinned_post.into_static(),
92
+
pronouns: self.pronouns.into_static(),
93
+
website: self.website.into_static(),
94
+
extra_data: self.extra_data.into_static(),
95
+
}
96
+
}
64
97
}
+11
-1
crates/jacquard-api/src/app_bsky/actor/put_preferences.rs
+11
-1
crates/jacquard-api/src/app_bsky/actor/put_preferences.rs
···
13
13
pub preferences: crate::app_bsky::actor::Preferences<'a>,
14
14
}
15
15
16
+
impl jacquard_common::IntoStatic for PutPreferences<'_> {
17
+
type Output = PutPreferences<'static>;
18
+
fn into_static(self) -> Self::Output {
19
+
PutPreferences {
20
+
preferences: self.preferences.into_static(),
21
+
extra_data: self.extra_data.into_static(),
22
+
}
23
+
}
24
+
}
25
+
16
26
impl jacquard_common::types::xrpc::XrpcRequest for PutPreferences<'_> {
17
27
const NSID: &'static str = "app.bsky.actor.putPreferences";
18
28
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
20
30
);
21
31
const OUTPUT_ENCODING: &'static str = "application/json";
22
32
type Output<'de> = ();
23
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
33
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
24
34
}
+22
-9
crates/jacquard-api/src/app_bsky/actor/search_actors.rs
+22
-9
crates/jacquard-api/src/app_bsky/actor/search_actors.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct SearchActors<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
12
#[serde(borrow)]
13
13
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
14
+
///(default: 25, min: 1, max: 100)
14
15
#[serde(skip_serializing_if = "std::option::Option::is_none")]
15
16
pub limit: std::option::Option<i64>,
16
17
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
21
22
pub term: std::option::Option<jacquard_common::CowStr<'a>>,
22
23
}
23
24
24
-
impl Default for SearchActors<'_> {
25
-
fn default() -> Self {
26
-
Self {
27
-
cursor: Default::default(),
28
-
limit: Some(25i64),
29
-
q: Default::default(),
30
-
term: Default::default(),
25
+
impl jacquard_common::IntoStatic for SearchActors<'_> {
26
+
type Output = SearchActors<'static>;
27
+
fn into_static(self) -> Self::Output {
28
+
SearchActors {
29
+
cursor: self.cursor.into_static(),
30
+
limit: self.limit.into_static(),
31
+
q: self.q.into_static(),
32
+
term: self.term.into_static(),
31
33
}
32
34
}
33
35
}
···
43
45
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
44
46
}
45
47
48
+
impl jacquard_common::IntoStatic for SearchActorsOutput<'_> {
49
+
type Output = SearchActorsOutput<'static>;
50
+
fn into_static(self) -> Self::Output {
51
+
SearchActorsOutput {
52
+
actors: self.actors.into_static(),
53
+
cursor: self.cursor.into_static(),
54
+
extra_data: self.extra_data.into_static(),
55
+
}
56
+
}
57
+
}
58
+
46
59
impl jacquard_common::types::xrpc::XrpcRequest for SearchActors<'_> {
47
60
const NSID: &'static str = "app.bsky.actor.searchActors";
48
61
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
49
62
const OUTPUT_ENCODING: &'static str = "application/json";
50
63
type Output<'de> = SearchActorsOutput<'de>;
51
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
64
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
52
65
}
+20
-8
crates/jacquard-api/src/app_bsky/actor/search_actors_typeahead.rs
+20
-8
crates/jacquard-api/src/app_bsky/actor/search_actors_typeahead.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct SearchActorsTypeahead<'a> {
11
+
///(default: 10, min: 1, max: 100)
11
12
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
13
pub limit: std::option::Option<i64>,
13
14
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
18
19
pub term: std::option::Option<jacquard_common::CowStr<'a>>,
19
20
}
20
21
21
-
impl Default for SearchActorsTypeahead<'_> {
22
-
fn default() -> Self {
23
-
Self {
24
-
limit: Some(10i64),
25
-
q: Default::default(),
26
-
term: Default::default(),
22
+
impl jacquard_common::IntoStatic for SearchActorsTypeahead<'_> {
23
+
type Output = SearchActorsTypeahead<'static>;
24
+
fn into_static(self) -> Self::Output {
25
+
SearchActorsTypeahead {
26
+
limit: self.limit.into_static(),
27
+
q: self.q.into_static(),
28
+
term: self.term.into_static(),
27
29
}
28
30
}
29
31
}
···
36
38
pub actors: Vec<crate::app_bsky::actor::ProfileViewBasic<'a>>,
37
39
}
38
40
41
+
impl jacquard_common::IntoStatic for SearchActorsTypeaheadOutput<'_> {
42
+
type Output = SearchActorsTypeaheadOutput<'static>;
43
+
fn into_static(self) -> Self::Output {
44
+
SearchActorsTypeaheadOutput {
45
+
actors: self.actors.into_static(),
46
+
extra_data: self.extra_data.into_static(),
47
+
}
48
+
}
49
+
}
50
+
39
51
impl jacquard_common::types::xrpc::XrpcRequest for SearchActorsTypeahead<'_> {
40
52
const NSID: &'static str = "app.bsky.actor.searchActorsTypeahead";
41
53
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
42
54
const OUTPUT_ENCODING: &'static str = "application/json";
43
55
type Output<'de> = SearchActorsTypeaheadOutput<'de>;
44
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
56
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
45
57
}
+25
crates/jacquard-api/src/app_bsky/actor/status.rs
+25
crates/jacquard-api/src/app_bsky/actor/status.rs
···
32
32
External(Box<crate::app_bsky::embed::external::ExternalRecord<'a>>),
33
33
}
34
34
35
+
impl jacquard_common::IntoStatic for StatusRecordEmbed<'_> {
36
+
type Output = StatusRecordEmbed<'static>;
37
+
fn into_static(self) -> Self::Output {
38
+
match self {
39
+
StatusRecordEmbed::External(v) => {
40
+
StatusRecordEmbed::External(v.into_static())
41
+
}
42
+
StatusRecordEmbed::Unknown(v) => StatusRecordEmbed::Unknown(v.into_static()),
43
+
}
44
+
}
45
+
}
46
+
35
47
impl jacquard_common::types::collection::Collection for Status<'_> {
36
48
const NSID: &'static str = "app.bsky.actor.status";
49
+
}
50
+
51
+
impl jacquard_common::IntoStatic for Status<'_> {
52
+
type Output = Status<'static>;
53
+
fn into_static(self) -> Self::Output {
54
+
Status {
55
+
created_at: self.created_at.into_static(),
56
+
duration_minutes: self.duration_minutes.into_static(),
57
+
embed: self.embed.into_static(),
58
+
status: self.status.into_static(),
59
+
extra_data: self.extra_data.into_static(),
60
+
}
61
+
}
37
62
}
+42
crates/jacquard-api/src/app_bsky/bookmark.rs
+42
crates/jacquard-api/src/app_bsky/bookmark.rs
···
19
19
pub subject: crate::com_atproto::repo::strong_ref::StrongRef<'a>,
20
20
}
21
21
22
+
impl jacquard_common::IntoStatic for Bookmark<'_> {
23
+
type Output = Bookmark<'static>;
24
+
fn into_static(self) -> Self::Output {
25
+
Bookmark {
26
+
subject: self.subject.into_static(),
27
+
extra_data: self.extra_data.into_static(),
28
+
}
29
+
}
30
+
}
31
+
22
32
#[jacquard_derive::lexicon]
23
33
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
24
34
#[serde(rename_all = "camelCase")]
···
43
53
DefsNotFoundPost(Box<crate::app_bsky::feed::NotFoundPost<'a>>),
44
54
#[serde(rename = "app.bsky.feed.defs#postView")]
45
55
DefsPostView(Box<crate::app_bsky::feed::PostView<'a>>),
56
+
}
57
+
58
+
impl jacquard_common::IntoStatic for BookmarkViewRecordItem<'_> {
59
+
type Output = BookmarkViewRecordItem<'static>;
60
+
fn into_static(self) -> Self::Output {
61
+
match self {
62
+
BookmarkViewRecordItem::DefsBlockedPost(v) => {
63
+
BookmarkViewRecordItem::DefsBlockedPost(v.into_static())
64
+
}
65
+
BookmarkViewRecordItem::DefsNotFoundPost(v) => {
66
+
BookmarkViewRecordItem::DefsNotFoundPost(v.into_static())
67
+
}
68
+
BookmarkViewRecordItem::DefsPostView(v) => {
69
+
BookmarkViewRecordItem::DefsPostView(v.into_static())
70
+
}
71
+
BookmarkViewRecordItem::Unknown(v) => {
72
+
BookmarkViewRecordItem::Unknown(v.into_static())
73
+
}
74
+
}
75
+
}
76
+
}
77
+
78
+
impl jacquard_common::IntoStatic for BookmarkView<'_> {
79
+
type Output = BookmarkView<'static>;
80
+
fn into_static(self) -> Self::Output {
81
+
BookmarkView {
82
+
created_at: self.created_at.into_static(),
83
+
item: self.item.into_static(),
84
+
subject: self.subject.into_static(),
85
+
extra_data: self.extra_data.into_static(),
86
+
}
87
+
}
46
88
}
+25
crates/jacquard-api/src/app_bsky/bookmark/create_bookmark.rs
+25
crates/jacquard-api/src/app_bsky/bookmark/create_bookmark.rs
···
15
15
pub uri: jacquard_common::types::string::AtUri<'a>,
16
16
}
17
17
18
+
impl jacquard_common::IntoStatic for CreateBookmark<'_> {
19
+
type Output = CreateBookmark<'static>;
20
+
fn into_static(self) -> Self::Output {
21
+
CreateBookmark {
22
+
cid: self.cid.into_static(),
23
+
uri: self.uri.into_static(),
24
+
extra_data: self.extra_data.into_static(),
25
+
}
26
+
}
27
+
}
28
+
18
29
#[jacquard_derive::open_union]
19
30
#[derive(
20
31
serde::Serialize,
···
45
56
Ok(())
46
57
}
47
58
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
59
+
}
60
+
}
61
+
}
62
+
63
+
impl jacquard_common::IntoStatic for CreateBookmarkError<'_> {
64
+
type Output = CreateBookmarkError<'static>;
65
+
fn into_static(self) -> Self::Output {
66
+
match self {
67
+
CreateBookmarkError::UnsupportedCollection(v) => {
68
+
CreateBookmarkError::UnsupportedCollection(v.into_static())
69
+
}
70
+
CreateBookmarkError::Unknown(v) => {
71
+
CreateBookmarkError::Unknown(v.into_static())
72
+
}
48
73
}
49
74
}
50
75
}
+24
crates/jacquard-api/src/app_bsky/bookmark/delete_bookmark.rs
+24
crates/jacquard-api/src/app_bsky/bookmark/delete_bookmark.rs
···
13
13
pub uri: jacquard_common::types::string::AtUri<'a>,
14
14
}
15
15
16
+
impl jacquard_common::IntoStatic for DeleteBookmark<'_> {
17
+
type Output = DeleteBookmark<'static>;
18
+
fn into_static(self) -> Self::Output {
19
+
DeleteBookmark {
20
+
uri: self.uri.into_static(),
21
+
extra_data: self.extra_data.into_static(),
22
+
}
23
+
}
24
+
}
25
+
16
26
#[jacquard_derive::open_union]
17
27
#[derive(
18
28
serde::Serialize,
···
43
53
Ok(())
44
54
}
45
55
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
56
+
}
57
+
}
58
+
}
59
+
60
+
impl jacquard_common::IntoStatic for DeleteBookmarkError<'_> {
61
+
type Output = DeleteBookmarkError<'static>;
62
+
fn into_static(self) -> Self::Output {
63
+
match self {
64
+
DeleteBookmarkError::UnsupportedCollection(v) => {
65
+
DeleteBookmarkError::UnsupportedCollection(v.into_static())
66
+
}
67
+
DeleteBookmarkError::Unknown(v) => {
68
+
DeleteBookmarkError::Unknown(v.into_static())
69
+
}
46
70
}
47
71
}
48
72
}
+20
-7
crates/jacquard-api/src/app_bsky/bookmark/get_bookmarks.rs
+20
-7
crates/jacquard-api/src/app_bsky/bookmark/get_bookmarks.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetBookmarks<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
12
#[serde(borrow)]
13
13
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
14
+
///(default: 50, min: 1, max: 100)
14
15
#[serde(skip_serializing_if = "std::option::Option::is_none")]
15
16
pub limit: std::option::Option<i64>,
16
17
}
17
18
18
-
impl Default for GetBookmarks<'_> {
19
-
fn default() -> Self {
20
-
Self {
21
-
cursor: Default::default(),
22
-
limit: Some(50i64),
19
+
impl jacquard_common::IntoStatic for GetBookmarks<'_> {
20
+
type Output = GetBookmarks<'static>;
21
+
fn into_static(self) -> Self::Output {
22
+
GetBookmarks {
23
+
cursor: self.cursor.into_static(),
24
+
limit: self.limit.into_static(),
23
25
}
24
26
}
25
27
}
···
35
37
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
36
38
}
37
39
40
+
impl jacquard_common::IntoStatic for GetBookmarksOutput<'_> {
41
+
type Output = GetBookmarksOutput<'static>;
42
+
fn into_static(self) -> Self::Output {
43
+
GetBookmarksOutput {
44
+
bookmarks: self.bookmarks.into_static(),
45
+
cursor: self.cursor.into_static(),
46
+
extra_data: self.extra_data.into_static(),
47
+
}
48
+
}
49
+
}
50
+
38
51
impl jacquard_common::types::xrpc::XrpcRequest for GetBookmarks<'_> {
39
52
const NSID: &'static str = "app.bsky.bookmark.getBookmarks";
40
53
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
41
54
const OUTPUT_ENCODING: &'static str = "application/json";
42
55
type Output<'de> = GetBookmarksOutput<'de>;
43
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
56
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
44
57
}
+11
crates/jacquard-api/src/app_bsky/embed.rs
+11
crates/jacquard-api/src/app_bsky/embed.rs
···
18
18
pub struct AspectRatio<'a> {
19
19
pub height: i64,
20
20
pub width: i64,
21
+
}
22
+
23
+
impl jacquard_common::IntoStatic for AspectRatio<'_> {
24
+
type Output = AspectRatio<'static>;
25
+
fn into_static(self) -> Self::Output {
26
+
AspectRatio {
27
+
height: self.height.into_static(),
28
+
width: self.width.into_static(),
29
+
extra_data: self.extra_data.into_static(),
30
+
}
31
+
}
21
32
}
+46
crates/jacquard-api/src/app_bsky/embed/external.rs
+46
crates/jacquard-api/src/app_bsky/embed/external.rs
···
20
20
pub uri: jacquard_common::types::string::Uri<'a>,
21
21
}
22
22
23
+
impl jacquard_common::IntoStatic for External<'_> {
24
+
type Output = External<'static>;
25
+
fn into_static(self) -> Self::Output {
26
+
External {
27
+
description: self.description.into_static(),
28
+
thumb: self.thumb.into_static(),
29
+
title: self.title.into_static(),
30
+
uri: self.uri.into_static(),
31
+
extra_data: self.extra_data.into_static(),
32
+
}
33
+
}
34
+
}
35
+
23
36
///A representation of some externally linked content (eg, a URL and 'card'), embedded in a Bluesky record (eg, a post).
24
37
#[jacquard_derive::lexicon]
25
38
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
27
40
pub struct ExternalRecord<'a> {
28
41
#[serde(borrow)]
29
42
pub external: crate::app_bsky::embed::external::External<'a>,
43
+
}
44
+
45
+
impl jacquard_common::IntoStatic for ExternalRecord<'_> {
46
+
type Output = ExternalRecord<'static>;
47
+
fn into_static(self) -> Self::Output {
48
+
ExternalRecord {
49
+
external: self.external.into_static(),
50
+
extra_data: self.extra_data.into_static(),
51
+
}
52
+
}
30
53
}
31
54
32
55
#[jacquard_derive::lexicon]
···
37
60
pub external: crate::app_bsky::embed::external::ViewExternal<'a>,
38
61
}
39
62
63
+
impl jacquard_common::IntoStatic for View<'_> {
64
+
type Output = View<'static>;
65
+
fn into_static(self) -> Self::Output {
66
+
View {
67
+
external: self.external.into_static(),
68
+
extra_data: self.extra_data.into_static(),
69
+
}
70
+
}
71
+
}
72
+
40
73
#[jacquard_derive::lexicon]
41
74
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
42
75
#[serde(rename_all = "camelCase")]
···
50
83
pub title: jacquard_common::CowStr<'a>,
51
84
#[serde(borrow)]
52
85
pub uri: jacquard_common::types::string::Uri<'a>,
86
+
}
87
+
88
+
impl jacquard_common::IntoStatic for ViewExternal<'_> {
89
+
type Output = ViewExternal<'static>;
90
+
fn into_static(self) -> Self::Output {
91
+
ViewExternal {
92
+
description: self.description.into_static(),
93
+
thumb: self.thumb.into_static(),
94
+
title: self.title.into_static(),
95
+
uri: self.uri.into_static(),
96
+
extra_data: self.extra_data.into_static(),
97
+
}
98
+
}
53
99
}
+45
crates/jacquard-api/src/app_bsky/embed/images.rs
+45
crates/jacquard-api/src/app_bsky/embed/images.rs
···
19
19
pub image: jacquard_common::types::blob::Blob<'a>,
20
20
}
21
21
22
+
impl jacquard_common::IntoStatic for Image<'_> {
23
+
type Output = Image<'static>;
24
+
fn into_static(self) -> Self::Output {
25
+
Image {
26
+
alt: self.alt.into_static(),
27
+
aspect_ratio: self.aspect_ratio.into_static(),
28
+
image: self.image.into_static(),
29
+
extra_data: self.extra_data.into_static(),
30
+
}
31
+
}
32
+
}
33
+
22
34
#[jacquard_derive::lexicon]
23
35
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
24
36
#[serde(rename_all = "camelCase")]
···
27
39
pub images: Vec<crate::app_bsky::embed::images::Image<'a>>,
28
40
}
29
41
42
+
impl jacquard_common::IntoStatic for Images<'_> {
43
+
type Output = Images<'static>;
44
+
fn into_static(self) -> Self::Output {
45
+
Images {
46
+
images: self.images.into_static(),
47
+
extra_data: self.extra_data.into_static(),
48
+
}
49
+
}
50
+
}
51
+
30
52
#[jacquard_derive::lexicon]
31
53
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
32
54
#[serde(rename_all = "camelCase")]
···
35
57
pub images: Vec<crate::app_bsky::embed::images::ViewImage<'a>>,
36
58
}
37
59
60
+
impl jacquard_common::IntoStatic for View<'_> {
61
+
type Output = View<'static>;
62
+
fn into_static(self) -> Self::Output {
63
+
View {
64
+
images: self.images.into_static(),
65
+
extra_data: self.extra_data.into_static(),
66
+
}
67
+
}
68
+
}
69
+
38
70
#[jacquard_derive::lexicon]
39
71
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
40
72
#[serde(rename_all = "camelCase")]
···
51
83
///Fully-qualified URL where a thumbnail of the image can be fetched. For example, CDN location provided by the App View.
52
84
#[serde(borrow)]
53
85
pub thumb: jacquard_common::types::string::Uri<'a>,
86
+
}
87
+
88
+
impl jacquard_common::IntoStatic for ViewImage<'_> {
89
+
type Output = ViewImage<'static>;
90
+
fn into_static(self) -> Self::Output {
91
+
ViewImage {
92
+
alt: self.alt.into_static(),
93
+
aspect_ratio: self.aspect_ratio.into_static(),
94
+
fullsize: self.fullsize.into_static(),
95
+
thumb: self.thumb.into_static(),
96
+
extra_data: self.extra_data.into_static(),
97
+
}
98
+
}
54
99
}
+95
crates/jacquard-api/src/app_bsky/embed/record.rs
+95
crates/jacquard-api/src/app_bsky/embed/record.rs
···
13
13
pub record: crate::com_atproto::repo::strong_ref::StrongRef<'a>,
14
14
}
15
15
16
+
impl jacquard_common::IntoStatic for Record<'_> {
17
+
type Output = Record<'static>;
18
+
fn into_static(self) -> Self::Output {
19
+
Record {
20
+
record: self.record.into_static(),
21
+
extra_data: self.extra_data.into_static(),
22
+
}
23
+
}
24
+
}
25
+
16
26
#[jacquard_derive::lexicon]
17
27
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
18
28
#[serde(rename_all = "camelCase")]
···
36
46
DefsStarterPackViewBasic(Box<crate::app_bsky::graph::StarterPackViewBasic<'a>>),
37
47
}
38
48
49
+
impl jacquard_common::IntoStatic for ViewRecordRecord<'_> {
50
+
type Output = ViewRecordRecord<'static>;
51
+
fn into_static(self) -> Self::Output {
52
+
match self {
53
+
ViewRecordRecord::DefsGeneratorView(v) => {
54
+
ViewRecordRecord::DefsGeneratorView(v.into_static())
55
+
}
56
+
ViewRecordRecord::DefsListView(v) => {
57
+
ViewRecordRecord::DefsListView(v.into_static())
58
+
}
59
+
ViewRecordRecord::DefsLabelerView(v) => {
60
+
ViewRecordRecord::DefsLabelerView(v.into_static())
61
+
}
62
+
ViewRecordRecord::DefsStarterPackViewBasic(v) => {
63
+
ViewRecordRecord::DefsStarterPackViewBasic(v.into_static())
64
+
}
65
+
ViewRecordRecord::Unknown(v) => ViewRecordRecord::Unknown(v.into_static()),
66
+
}
67
+
}
68
+
}
69
+
70
+
impl jacquard_common::IntoStatic for View<'_> {
71
+
type Output = View<'static>;
72
+
fn into_static(self) -> Self::Output {
73
+
View {
74
+
record: self.record.into_static(),
75
+
extra_data: self.extra_data.into_static(),
76
+
}
77
+
}
78
+
}
79
+
39
80
#[jacquard_derive::lexicon]
40
81
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
41
82
#[serde(rename_all = "camelCase")]
···
47
88
pub uri: jacquard_common::types::string::AtUri<'a>,
48
89
}
49
90
91
+
impl jacquard_common::IntoStatic for ViewBlocked<'_> {
92
+
type Output = ViewBlocked<'static>;
93
+
fn into_static(self) -> Self::Output {
94
+
ViewBlocked {
95
+
author: self.author.into_static(),
96
+
blocked: self.blocked.into_static(),
97
+
uri: self.uri.into_static(),
98
+
extra_data: self.extra_data.into_static(),
99
+
}
100
+
}
101
+
}
102
+
50
103
#[jacquard_derive::lexicon]
51
104
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
52
105
#[serde(rename_all = "camelCase")]
···
56
109
pub uri: jacquard_common::types::string::AtUri<'a>,
57
110
}
58
111
112
+
impl jacquard_common::IntoStatic for ViewDetached<'_> {
113
+
type Output = ViewDetached<'static>;
114
+
fn into_static(self) -> Self::Output {
115
+
ViewDetached {
116
+
detached: self.detached.into_static(),
117
+
uri: self.uri.into_static(),
118
+
extra_data: self.extra_data.into_static(),
119
+
}
120
+
}
121
+
}
122
+
59
123
#[jacquard_derive::lexicon]
60
124
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
61
125
#[serde(rename_all = "camelCase")]
···
65
129
pub uri: jacquard_common::types::string::AtUri<'a>,
66
130
}
67
131
132
+
impl jacquard_common::IntoStatic for ViewNotFound<'_> {
133
+
type Output = ViewNotFound<'static>;
134
+
fn into_static(self) -> Self::Output {
135
+
ViewNotFound {
136
+
not_found: self.not_found.into_static(),
137
+
uri: self.uri.into_static(),
138
+
extra_data: self.extra_data.into_static(),
139
+
}
140
+
}
141
+
}
142
+
68
143
#[jacquard_derive::lexicon]
69
144
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
70
145
#[serde(rename_all = "camelCase")]
···
93
168
///The record data itself.
94
169
#[serde(borrow)]
95
170
pub value: jacquard_common::types::value::Data<'a>,
171
+
}
172
+
173
+
impl jacquard_common::IntoStatic for ViewRecord<'_> {
174
+
type Output = ViewRecord<'static>;
175
+
fn into_static(self) -> Self::Output {
176
+
ViewRecord {
177
+
author: self.author.into_static(),
178
+
cid: self.cid.into_static(),
179
+
embeds: self.embeds.into_static(),
180
+
indexed_at: self.indexed_at.into_static(),
181
+
labels: self.labels.into_static(),
182
+
like_count: self.like_count.into_static(),
183
+
quote_count: self.quote_count.into_static(),
184
+
reply_count: self.reply_count.into_static(),
185
+
repost_count: self.repost_count.into_static(),
186
+
uri: self.uri.into_static(),
187
+
value: self.value.into_static(),
188
+
extra_data: self.extra_data.into_static(),
189
+
}
190
+
}
96
191
}
+58
crates/jacquard-api/src/app_bsky/embed/record_with_media.rs
+58
crates/jacquard-api/src/app_bsky/embed/record_with_media.rs
···
28
28
External(Box<crate::app_bsky::embed::external::ExternalRecord<'a>>),
29
29
}
30
30
31
+
impl jacquard_common::IntoStatic for RecordWithMediaRecordMedia<'_> {
32
+
type Output = RecordWithMediaRecordMedia<'static>;
33
+
fn into_static(self) -> Self::Output {
34
+
match self {
35
+
RecordWithMediaRecordMedia::Images(v) => {
36
+
RecordWithMediaRecordMedia::Images(v.into_static())
37
+
}
38
+
RecordWithMediaRecordMedia::Video(v) => {
39
+
RecordWithMediaRecordMedia::Video(v.into_static())
40
+
}
41
+
RecordWithMediaRecordMedia::External(v) => {
42
+
RecordWithMediaRecordMedia::External(v.into_static())
43
+
}
44
+
RecordWithMediaRecordMedia::Unknown(v) => {
45
+
RecordWithMediaRecordMedia::Unknown(v.into_static())
46
+
}
47
+
}
48
+
}
49
+
}
50
+
51
+
impl jacquard_common::IntoStatic for RecordWithMedia<'_> {
52
+
type Output = RecordWithMedia<'static>;
53
+
fn into_static(self) -> Self::Output {
54
+
RecordWithMedia {
55
+
media: self.media.into_static(),
56
+
record: self.record.into_static(),
57
+
extra_data: self.extra_data.into_static(),
58
+
}
59
+
}
60
+
}
61
+
31
62
#[jacquard_derive::lexicon]
32
63
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
33
64
#[serde(rename_all = "camelCase")]
···
49
80
VideoView(Box<crate::app_bsky::embed::video::View<'a>>),
50
81
#[serde(rename = "app.bsky.embed.external#view")]
51
82
ExternalView(Box<crate::app_bsky::embed::external::View<'a>>),
83
+
}
84
+
85
+
impl jacquard_common::IntoStatic for ViewRecordMedia<'_> {
86
+
type Output = ViewRecordMedia<'static>;
87
+
fn into_static(self) -> Self::Output {
88
+
match self {
89
+
ViewRecordMedia::ImagesView(v) => {
90
+
ViewRecordMedia::ImagesView(v.into_static())
91
+
}
92
+
ViewRecordMedia::VideoView(v) => ViewRecordMedia::VideoView(v.into_static()),
93
+
ViewRecordMedia::ExternalView(v) => {
94
+
ViewRecordMedia::ExternalView(v.into_static())
95
+
}
96
+
ViewRecordMedia::Unknown(v) => ViewRecordMedia::Unknown(v.into_static()),
97
+
}
98
+
}
99
+
}
100
+
101
+
impl jacquard_common::IntoStatic for View<'_> {
102
+
type Output = View<'static>;
103
+
fn into_static(self) -> Self::Output {
104
+
View {
105
+
media: self.media.into_static(),
106
+
record: self.record.into_static(),
107
+
extra_data: self.extra_data.into_static(),
108
+
}
109
+
}
52
110
}
+38
crates/jacquard-api/src/app_bsky/embed/video.rs
+38
crates/jacquard-api/src/app_bsky/embed/video.rs
···
14
14
pub lang: jacquard_common::types::string::Language,
15
15
}
16
16
17
+
impl jacquard_common::IntoStatic for Caption<'_> {
18
+
type Output = Caption<'static>;
19
+
fn into_static(self) -> Self::Output {
20
+
Caption {
21
+
file: self.file.into_static(),
22
+
lang: self.lang.into_static(),
23
+
extra_data: self.extra_data.into_static(),
24
+
}
25
+
}
26
+
}
27
+
17
28
#[jacquard_derive::lexicon]
18
29
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
19
30
#[serde(rename_all = "camelCase")]
···
33
44
pub video: jacquard_common::types::blob::Blob<'a>,
34
45
}
35
46
47
+
impl jacquard_common::IntoStatic for Video<'_> {
48
+
type Output = Video<'static>;
49
+
fn into_static(self) -> Self::Output {
50
+
Video {
51
+
alt: self.alt.into_static(),
52
+
aspect_ratio: self.aspect_ratio.into_static(),
53
+
captions: self.captions.into_static(),
54
+
video: self.video.into_static(),
55
+
extra_data: self.extra_data.into_static(),
56
+
}
57
+
}
58
+
}
59
+
36
60
#[jacquard_derive::lexicon]
37
61
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
38
62
#[serde(rename_all = "camelCase")]
···
50
74
#[serde(skip_serializing_if = "std::option::Option::is_none")]
51
75
#[serde(borrow)]
52
76
pub thumbnail: std::option::Option<jacquard_common::types::string::Uri<'a>>,
77
+
}
78
+
79
+
impl jacquard_common::IntoStatic for View<'_> {
80
+
type Output = View<'static>;
81
+
fn into_static(self) -> Self::Output {
82
+
View {
83
+
alt: self.alt.into_static(),
84
+
aspect_ratio: self.aspect_ratio.into_static(),
85
+
cid: self.cid.into_static(),
86
+
playlist: self.playlist.into_static(),
87
+
thumbnail: self.thumbnail.into_static(),
88
+
extra_data: self.extra_data.into_static(),
89
+
}
90
+
}
53
91
}
+315
crates/jacquard-api/src/app_bsky/feed.rs
+315
crates/jacquard-api/src/app_bsky/feed.rs
···
41
41
pub viewer: std::option::Option<crate::app_bsky::actor::ViewerState<'a>>,
42
42
}
43
43
44
+
impl jacquard_common::IntoStatic for BlockedAuthor<'_> {
45
+
type Output = BlockedAuthor<'static>;
46
+
fn into_static(self) -> Self::Output {
47
+
BlockedAuthor {
48
+
did: self.did.into_static(),
49
+
viewer: self.viewer.into_static(),
50
+
extra_data: self.extra_data.into_static(),
51
+
}
52
+
}
53
+
}
54
+
44
55
#[jacquard_derive::lexicon]
45
56
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
46
57
#[serde(rename_all = "camelCase")]
···
52
63
pub uri: jacquard_common::types::string::AtUri<'a>,
53
64
}
54
65
66
+
impl jacquard_common::IntoStatic for BlockedPost<'_> {
67
+
type Output = BlockedPost<'static>;
68
+
fn into_static(self) -> Self::Output {
69
+
BlockedPost {
70
+
author: self.author.into_static(),
71
+
blocked: self.blocked.into_static(),
72
+
uri: self.uri.into_static(),
73
+
extra_data: self.extra_data.into_static(),
74
+
}
75
+
}
76
+
}
77
+
55
78
#[jacquard_derive::lexicon]
56
79
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
57
80
#[serde(rename_all = "camelCase")]
···
79
102
#[serde(tag = "$type")]
80
103
#[serde(bound(deserialize = "'de: 'a"))]
81
104
pub enum FeedViewPostRecordReason<'a> {}
105
+
impl jacquard_common::IntoStatic for FeedViewPostRecordReason<'_> {
106
+
type Output = FeedViewPostRecordReason<'static>;
107
+
fn into_static(self) -> Self::Output {
108
+
match self {
109
+
FeedViewPostRecordReason::Unknown(v) => {
110
+
FeedViewPostRecordReason::Unknown(v.into_static())
111
+
}
112
+
}
113
+
}
114
+
}
115
+
116
+
impl jacquard_common::IntoStatic for FeedViewPost<'_> {
117
+
type Output = FeedViewPost<'static>;
118
+
fn into_static(self) -> Self::Output {
119
+
FeedViewPost {
120
+
feed_context: self.feed_context.into_static(),
121
+
post: self.post.into_static(),
122
+
reason: self.reason.into_static(),
123
+
reply: self.reply.into_static(),
124
+
req_id: self.req_id.into_static(),
125
+
extra_data: self.extra_data.into_static(),
126
+
}
127
+
}
128
+
}
129
+
82
130
#[jacquard_derive::lexicon]
83
131
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
84
132
#[serde(rename_all = "camelCase")]
···
120
168
pub viewer: std::option::Option<crate::app_bsky::feed::GeneratorViewerState<'a>>,
121
169
}
122
170
171
+
impl jacquard_common::IntoStatic for GeneratorView<'_> {
172
+
type Output = GeneratorView<'static>;
173
+
fn into_static(self) -> Self::Output {
174
+
GeneratorView {
175
+
accepts_interactions: self.accepts_interactions.into_static(),
176
+
avatar: self.avatar.into_static(),
177
+
cid: self.cid.into_static(),
178
+
content_mode: self.content_mode.into_static(),
179
+
creator: self.creator.into_static(),
180
+
description: self.description.into_static(),
181
+
description_facets: self.description_facets.into_static(),
182
+
did: self.did.into_static(),
183
+
display_name: self.display_name.into_static(),
184
+
indexed_at: self.indexed_at.into_static(),
185
+
labels: self.labels.into_static(),
186
+
like_count: self.like_count.into_static(),
187
+
uri: self.uri.into_static(),
188
+
viewer: self.viewer.into_static(),
189
+
extra_data: self.extra_data.into_static(),
190
+
}
191
+
}
192
+
}
193
+
123
194
#[jacquard_derive::lexicon]
124
195
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
125
196
#[serde(rename_all = "camelCase")]
···
129
200
pub like: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
130
201
}
131
202
203
+
impl jacquard_common::IntoStatic for GeneratorViewerState<'_> {
204
+
type Output = GeneratorViewerState<'static>;
205
+
fn into_static(self) -> Self::Output {
206
+
GeneratorViewerState {
207
+
like: self.like.into_static(),
208
+
extra_data: self.extra_data.into_static(),
209
+
}
210
+
}
211
+
}
212
+
132
213
#[jacquard_derive::lexicon]
133
214
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
134
215
#[serde(rename_all = "camelCase")]
···
149
230
pub req_id: std::option::Option<jacquard_common::CowStr<'a>>,
150
231
}
151
232
233
+
impl jacquard_common::IntoStatic for Interaction<'_> {
234
+
type Output = Interaction<'static>;
235
+
fn into_static(self) -> Self::Output {
236
+
Interaction {
237
+
event: self.event.into_static(),
238
+
feed_context: self.feed_context.into_static(),
239
+
item: self.item.into_static(),
240
+
req_id: self.req_id.into_static(),
241
+
extra_data: self.extra_data.into_static(),
242
+
}
243
+
}
244
+
}
245
+
152
246
#[jacquard_derive::lexicon]
153
247
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
154
248
#[serde(rename_all = "camelCase")]
···
158
252
pub uri: jacquard_common::types::string::AtUri<'a>,
159
253
}
160
254
255
+
impl jacquard_common::IntoStatic for NotFoundPost<'_> {
256
+
type Output = NotFoundPost<'static>;
257
+
fn into_static(self) -> Self::Output {
258
+
NotFoundPost {
259
+
not_found: self.not_found.into_static(),
260
+
uri: self.uri.into_static(),
261
+
extra_data: self.extra_data.into_static(),
262
+
}
263
+
}
264
+
}
265
+
161
266
#[jacquard_derive::lexicon]
162
267
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
163
268
#[serde(rename_all = "camelCase")]
···
212
317
RecordWithMediaView(Box<crate::app_bsky::embed::record_with_media::View<'a>>),
213
318
}
214
319
320
+
impl jacquard_common::IntoStatic for PostViewRecordEmbed<'_> {
321
+
type Output = PostViewRecordEmbed<'static>;
322
+
fn into_static(self) -> Self::Output {
323
+
match self {
324
+
PostViewRecordEmbed::ImagesView(v) => {
325
+
PostViewRecordEmbed::ImagesView(v.into_static())
326
+
}
327
+
PostViewRecordEmbed::VideoView(v) => {
328
+
PostViewRecordEmbed::VideoView(v.into_static())
329
+
}
330
+
PostViewRecordEmbed::ExternalView(v) => {
331
+
PostViewRecordEmbed::ExternalView(v.into_static())
332
+
}
333
+
PostViewRecordEmbed::RecordView(v) => {
334
+
PostViewRecordEmbed::RecordView(v.into_static())
335
+
}
336
+
PostViewRecordEmbed::RecordWithMediaView(v) => {
337
+
PostViewRecordEmbed::RecordWithMediaView(v.into_static())
338
+
}
339
+
PostViewRecordEmbed::Unknown(v) => {
340
+
PostViewRecordEmbed::Unknown(v.into_static())
341
+
}
342
+
}
343
+
}
344
+
}
345
+
346
+
impl jacquard_common::IntoStatic for PostView<'_> {
347
+
type Output = PostView<'static>;
348
+
fn into_static(self) -> Self::Output {
349
+
PostView {
350
+
author: self.author.into_static(),
351
+
bookmark_count: self.bookmark_count.into_static(),
352
+
cid: self.cid.into_static(),
353
+
embed: self.embed.into_static(),
354
+
indexed_at: self.indexed_at.into_static(),
355
+
labels: self.labels.into_static(),
356
+
like_count: self.like_count.into_static(),
357
+
quote_count: self.quote_count.into_static(),
358
+
record: self.record.into_static(),
359
+
reply_count: self.reply_count.into_static(),
360
+
repost_count: self.repost_count.into_static(),
361
+
threadgate: self.threadgate.into_static(),
362
+
uri: self.uri.into_static(),
363
+
viewer: self.viewer.into_static(),
364
+
extra_data: self.extra_data.into_static(),
365
+
}
366
+
}
367
+
}
368
+
215
369
#[jacquard_derive::lexicon]
216
370
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
217
371
#[serde(rename_all = "camelCase")]
218
372
pub struct ReasonPin<'a> {}
373
+
impl jacquard_common::IntoStatic for ReasonPin<'_> {
374
+
type Output = ReasonPin<'static>;
375
+
fn into_static(self) -> Self::Output {
376
+
ReasonPin {
377
+
extra_data: self.extra_data.into_static(),
378
+
}
379
+
}
380
+
}
381
+
219
382
#[jacquard_derive::lexicon]
220
383
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
221
384
#[serde(rename_all = "camelCase")]
···
231
394
pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
232
395
}
233
396
397
+
impl jacquard_common::IntoStatic for ReasonRepost<'_> {
398
+
type Output = ReasonRepost<'static>;
399
+
fn into_static(self) -> Self::Output {
400
+
ReasonRepost {
401
+
by: self.by.into_static(),
402
+
cid: self.cid.into_static(),
403
+
indexed_at: self.indexed_at.into_static(),
404
+
uri: self.uri.into_static(),
405
+
extra_data: self.extra_data.into_static(),
406
+
}
407
+
}
408
+
}
409
+
234
410
#[jacquard_derive::lexicon]
235
411
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
236
412
#[serde(rename_all = "camelCase")]
···
252
428
#[serde(tag = "$type")]
253
429
#[serde(bound(deserialize = "'de: 'a"))]
254
430
pub enum ReplyRefRecordParent<'a> {}
431
+
impl jacquard_common::IntoStatic for ReplyRefRecordParent<'_> {
432
+
type Output = ReplyRefRecordParent<'static>;
433
+
fn into_static(self) -> Self::Output {
434
+
match self {
435
+
ReplyRefRecordParent::Unknown(v) => {
436
+
ReplyRefRecordParent::Unknown(v.into_static())
437
+
}
438
+
}
439
+
}
440
+
}
441
+
255
442
#[jacquard_derive::open_union]
256
443
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
257
444
#[serde(tag = "$type")]
258
445
#[serde(bound(deserialize = "'de: 'a"))]
259
446
pub enum ReplyRefRecordRoot<'a> {}
447
+
impl jacquard_common::IntoStatic for ReplyRefRecordRoot<'_> {
448
+
type Output = ReplyRefRecordRoot<'static>;
449
+
fn into_static(self) -> Self::Output {
450
+
match self {
451
+
ReplyRefRecordRoot::Unknown(v) => {
452
+
ReplyRefRecordRoot::Unknown(v.into_static())
453
+
}
454
+
}
455
+
}
456
+
}
457
+
458
+
impl jacquard_common::IntoStatic for ReplyRef<'_> {
459
+
type Output = ReplyRef<'static>;
460
+
fn into_static(self) -> Self::Output {
461
+
ReplyRef {
462
+
grandparent_author: self.grandparent_author.into_static(),
463
+
parent: self.parent.into_static(),
464
+
root: self.root.into_static(),
465
+
extra_data: self.extra_data.into_static(),
466
+
}
467
+
}
468
+
}
469
+
260
470
#[jacquard_derive::lexicon]
261
471
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
262
472
#[serde(rename_all = "camelCase")]
···
277
487
#[serde(tag = "$type")]
278
488
#[serde(bound(deserialize = "'de: 'a"))]
279
489
pub enum SkeletonFeedPostRecordReason<'a> {}
490
+
impl jacquard_common::IntoStatic for SkeletonFeedPostRecordReason<'_> {
491
+
type Output = SkeletonFeedPostRecordReason<'static>;
492
+
fn into_static(self) -> Self::Output {
493
+
match self {
494
+
SkeletonFeedPostRecordReason::Unknown(v) => {
495
+
SkeletonFeedPostRecordReason::Unknown(v.into_static())
496
+
}
497
+
}
498
+
}
499
+
}
500
+
501
+
impl jacquard_common::IntoStatic for SkeletonFeedPost<'_> {
502
+
type Output = SkeletonFeedPost<'static>;
503
+
fn into_static(self) -> Self::Output {
504
+
SkeletonFeedPost {
505
+
feed_context: self.feed_context.into_static(),
506
+
post: self.post.into_static(),
507
+
reason: self.reason.into_static(),
508
+
extra_data: self.extra_data.into_static(),
509
+
}
510
+
}
511
+
}
512
+
280
513
#[jacquard_derive::lexicon]
281
514
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
282
515
#[serde(rename_all = "camelCase")]
283
516
pub struct SkeletonReasonPin<'a> {}
517
+
impl jacquard_common::IntoStatic for SkeletonReasonPin<'_> {
518
+
type Output = SkeletonReasonPin<'static>;
519
+
fn into_static(self) -> Self::Output {
520
+
SkeletonReasonPin {
521
+
extra_data: self.extra_data.into_static(),
522
+
}
523
+
}
524
+
}
525
+
284
526
#[jacquard_derive::lexicon]
285
527
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
286
528
#[serde(rename_all = "camelCase")]
···
289
531
pub repost: jacquard_common::types::string::AtUri<'a>,
290
532
}
291
533
534
+
impl jacquard_common::IntoStatic for SkeletonReasonRepost<'_> {
535
+
type Output = SkeletonReasonRepost<'static>;
536
+
fn into_static(self) -> Self::Output {
537
+
SkeletonReasonRepost {
538
+
repost: self.repost.into_static(),
539
+
extra_data: self.extra_data.into_static(),
540
+
}
541
+
}
542
+
}
543
+
292
544
///Metadata about this post within the context of the thread it is in.
293
545
#[jacquard_derive::lexicon]
294
546
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
299
551
pub root_author_like: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
300
552
}
301
553
554
+
impl jacquard_common::IntoStatic for ThreadContext<'_> {
555
+
type Output = ThreadContext<'static>;
556
+
fn into_static(self) -> Self::Output {
557
+
ThreadContext {
558
+
root_author_like: self.root_author_like.into_static(),
559
+
extra_data: self.extra_data.into_static(),
560
+
}
561
+
}
562
+
}
563
+
302
564
#[jacquard_derive::lexicon]
303
565
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
304
566
#[serde(rename_all = "camelCase")]
···
321
583
#[serde(tag = "$type")]
322
584
#[serde(bound(deserialize = "'de: 'a"))]
323
585
pub enum ThreadViewPostRecordParent<'a> {}
586
+
impl jacquard_common::IntoStatic for ThreadViewPostRecordParent<'_> {
587
+
type Output = ThreadViewPostRecordParent<'static>;
588
+
fn into_static(self) -> Self::Output {
589
+
match self {
590
+
ThreadViewPostRecordParent::Unknown(v) => {
591
+
ThreadViewPostRecordParent::Unknown(v.into_static())
592
+
}
593
+
}
594
+
}
595
+
}
596
+
597
+
impl jacquard_common::IntoStatic for ThreadViewPost<'_> {
598
+
type Output = ThreadViewPost<'static>;
599
+
fn into_static(self) -> Self::Output {
600
+
ThreadViewPost {
601
+
parent: self.parent.into_static(),
602
+
post: self.post.into_static(),
603
+
replies: self.replies.into_static(),
604
+
thread_context: self.thread_context.into_static(),
605
+
extra_data: self.extra_data.into_static(),
606
+
}
607
+
}
608
+
}
609
+
324
610
#[jacquard_derive::lexicon]
325
611
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
326
612
#[serde(rename_all = "camelCase")]
···
339
625
pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
340
626
}
341
627
628
+
impl jacquard_common::IntoStatic for ThreadgateView<'_> {
629
+
type Output = ThreadgateView<'static>;
630
+
fn into_static(self) -> Self::Output {
631
+
ThreadgateView {
632
+
cid: self.cid.into_static(),
633
+
lists: self.lists.into_static(),
634
+
record: self.record.into_static(),
635
+
uri: self.uri.into_static(),
636
+
extra_data: self.extra_data.into_static(),
637
+
}
638
+
}
639
+
}
640
+
342
641
///Metadata about the requesting account's relationship with the subject content. Only has meaningful content for authed requests.
343
642
#[jacquard_derive::lexicon]
344
643
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
360
659
pub repost: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
361
660
#[serde(skip_serializing_if = "std::option::Option::is_none")]
362
661
pub thread_muted: std::option::Option<bool>,
662
+
}
663
+
664
+
impl jacquard_common::IntoStatic for ViewerState<'_> {
665
+
type Output = ViewerState<'static>;
666
+
fn into_static(self) -> Self::Output {
667
+
ViewerState {
668
+
bookmarked: self.bookmarked.into_static(),
669
+
embedding_disabled: self.embedding_disabled.into_static(),
670
+
like: self.like.into_static(),
671
+
pinned: self.pinned.into_static(),
672
+
reply_disabled: self.reply_disabled.into_static(),
673
+
repost: self.repost.into_static(),
674
+
thread_muted: self.thread_muted.into_static(),
675
+
extra_data: self.extra_data.into_static(),
676
+
}
677
+
}
363
678
}
+34
-1
crates/jacquard-api/src/app_bsky/feed/describe_feed_generator.rs
+34
-1
crates/jacquard-api/src/app_bsky/feed/describe_feed_generator.rs
···
13
13
pub uri: jacquard_common::types::string::AtUri<'a>,
14
14
}
15
15
16
+
impl jacquard_common::IntoStatic for Feed<'_> {
17
+
type Output = Feed<'static>;
18
+
fn into_static(self) -> Self::Output {
19
+
Feed {
20
+
uri: self.uri.into_static(),
21
+
extra_data: self.extra_data.into_static(),
22
+
}
23
+
}
24
+
}
25
+
16
26
#[jacquard_derive::lexicon]
17
27
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
18
28
#[serde(rename_all = "camelCase")]
···
25
35
pub terms_of_service: std::option::Option<jacquard_common::CowStr<'a>>,
26
36
}
27
37
38
+
impl jacquard_common::IntoStatic for Links<'_> {
39
+
type Output = Links<'static>;
40
+
fn into_static(self) -> Self::Output {
41
+
Links {
42
+
privacy_policy: self.privacy_policy.into_static(),
43
+
terms_of_service: self.terms_of_service.into_static(),
44
+
extra_data: self.extra_data.into_static(),
45
+
}
46
+
}
47
+
}
48
+
28
49
#[jacquard_derive::lexicon]
29
50
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
30
51
#[serde(rename_all = "camelCase")]
···
38
59
pub links: std::option::Option<jacquard_common::types::value::Data<'a>>,
39
60
}
40
61
62
+
impl jacquard_common::IntoStatic for DescribeFeedGeneratorOutput<'_> {
63
+
type Output = DescribeFeedGeneratorOutput<'static>;
64
+
fn into_static(self) -> Self::Output {
65
+
DescribeFeedGeneratorOutput {
66
+
did: self.did.into_static(),
67
+
feeds: self.feeds.into_static(),
68
+
links: self.links.into_static(),
69
+
extra_data: self.extra_data.into_static(),
70
+
}
71
+
}
72
+
}
73
+
41
74
/// XRPC request marker type
42
75
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]
43
76
pub struct DescribeFeedGenerator;
···
46
79
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
47
80
const OUTPUT_ENCODING: &'static str = "application/json";
48
81
type Output<'de> = DescribeFeedGeneratorOutput<'de>;
49
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
82
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
50
83
}
+32
crates/jacquard-api/src/app_bsky/feed/generator.rs
+32
crates/jacquard-api/src/app_bsky/feed/generator.rs
···
47
47
DefsSelfLabels(Box<crate::com_atproto::label::SelfLabels<'a>>),
48
48
}
49
49
50
+
impl jacquard_common::IntoStatic for GeneratorRecordLabels<'_> {
51
+
type Output = GeneratorRecordLabels<'static>;
52
+
fn into_static(self) -> Self::Output {
53
+
match self {
54
+
GeneratorRecordLabels::DefsSelfLabels(v) => {
55
+
GeneratorRecordLabels::DefsSelfLabels(v.into_static())
56
+
}
57
+
GeneratorRecordLabels::Unknown(v) => {
58
+
GeneratorRecordLabels::Unknown(v.into_static())
59
+
}
60
+
}
61
+
}
62
+
}
63
+
50
64
impl jacquard_common::types::collection::Collection for Generator<'_> {
51
65
const NSID: &'static str = "app.bsky.feed.generator";
66
+
}
67
+
68
+
impl jacquard_common::IntoStatic for Generator<'_> {
69
+
type Output = Generator<'static>;
70
+
fn into_static(self) -> Self::Output {
71
+
Generator {
72
+
accepts_interactions: self.accepts_interactions.into_static(),
73
+
avatar: self.avatar.into_static(),
74
+
content_mode: self.content_mode.into_static(),
75
+
created_at: self.created_at.into_static(),
76
+
description: self.description.into_static(),
77
+
description_facets: self.description_facets.into_static(),
78
+
did: self.did.into_static(),
79
+
display_name: self.display_name.into_static(),
80
+
labels: self.labels.into_static(),
81
+
extra_data: self.extra_data.into_static(),
82
+
}
83
+
}
52
84
}
+21
-8
crates/jacquard-api/src/app_bsky/feed/get_actor_feeds.rs
+21
-8
crates/jacquard-api/src/app_bsky/feed/get_actor_feeds.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetActorFeeds<'a> {
11
11
#[serde(borrow)]
···
13
13
#[serde(skip_serializing_if = "std::option::Option::is_none")]
14
14
#[serde(borrow)]
15
15
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
16
+
///(default: 50, min: 1, max: 100)
16
17
#[serde(skip_serializing_if = "std::option::Option::is_none")]
17
18
pub limit: std::option::Option<i64>,
18
19
}
19
20
20
-
impl Default for GetActorFeeds<'_> {
21
-
fn default() -> Self {
22
-
Self {
23
-
actor: Default::default(),
24
-
cursor: Default::default(),
25
-
limit: Some(50i64),
21
+
impl jacquard_common::IntoStatic for GetActorFeeds<'_> {
22
+
type Output = GetActorFeeds<'static>;
23
+
fn into_static(self) -> Self::Output {
24
+
GetActorFeeds {
25
+
actor: self.actor.into_static(),
26
+
cursor: self.cursor.into_static(),
27
+
limit: self.limit.into_static(),
26
28
}
27
29
}
28
30
}
···
38
40
pub feeds: Vec<crate::app_bsky::feed::GeneratorView<'a>>,
39
41
}
40
42
43
+
impl jacquard_common::IntoStatic for GetActorFeedsOutput<'_> {
44
+
type Output = GetActorFeedsOutput<'static>;
45
+
fn into_static(self) -> Self::Output {
46
+
GetActorFeedsOutput {
47
+
cursor: self.cursor.into_static(),
48
+
feeds: self.feeds.into_static(),
49
+
extra_data: self.extra_data.into_static(),
50
+
}
51
+
}
52
+
}
53
+
41
54
impl jacquard_common::types::xrpc::XrpcRequest for GetActorFeeds<'_> {
42
55
const NSID: &'static str = "app.bsky.feed.getActorFeeds";
43
56
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
44
57
const OUTPUT_ENCODING: &'static str = "application/json";
45
58
type Output<'de> = GetActorFeedsOutput<'de>;
46
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
59
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
47
60
}
+37
-7
crates/jacquard-api/src/app_bsky/feed/get_actor_likes.rs
+37
-7
crates/jacquard-api/src/app_bsky/feed/get_actor_likes.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetActorLikes<'a> {
11
11
#[serde(borrow)]
···
13
13
#[serde(skip_serializing_if = "std::option::Option::is_none")]
14
14
#[serde(borrow)]
15
15
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
16
+
///(default: 50, min: 1, max: 100)
16
17
#[serde(skip_serializing_if = "std::option::Option::is_none")]
17
18
pub limit: std::option::Option<i64>,
18
19
}
19
20
20
-
impl Default for GetActorLikes<'_> {
21
-
fn default() -> Self {
22
-
Self {
23
-
actor: Default::default(),
24
-
cursor: Default::default(),
25
-
limit: Some(50i64),
21
+
impl jacquard_common::IntoStatic for GetActorLikes<'_> {
22
+
type Output = GetActorLikes<'static>;
23
+
fn into_static(self) -> Self::Output {
24
+
GetActorLikes {
25
+
actor: self.actor.into_static(),
26
+
cursor: self.cursor.into_static(),
27
+
limit: self.limit.into_static(),
26
28
}
27
29
}
28
30
}
···
38
40
pub feed: Vec<crate::app_bsky::feed::FeedViewPost<'a>>,
39
41
}
40
42
43
+
impl jacquard_common::IntoStatic for GetActorLikesOutput<'_> {
44
+
type Output = GetActorLikesOutput<'static>;
45
+
fn into_static(self) -> Self::Output {
46
+
GetActorLikesOutput {
47
+
cursor: self.cursor.into_static(),
48
+
feed: self.feed.into_static(),
49
+
extra_data: self.extra_data.into_static(),
50
+
}
51
+
}
52
+
}
53
+
41
54
#[jacquard_derive::open_union]
42
55
#[derive(
43
56
serde::Serialize,
···
76
89
Ok(())
77
90
}
78
91
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
92
+
}
93
+
}
94
+
}
95
+
96
+
impl jacquard_common::IntoStatic for GetActorLikesError<'_> {
97
+
type Output = GetActorLikesError<'static>;
98
+
fn into_static(self) -> Self::Output {
99
+
match self {
100
+
GetActorLikesError::BlockedActor(v) => {
101
+
GetActorLikesError::BlockedActor(v.into_static())
102
+
}
103
+
GetActorLikesError::BlockedByActor(v) => {
104
+
GetActorLikesError::BlockedByActor(v.into_static())
105
+
}
106
+
GetActorLikesError::Unknown(v) => {
107
+
GetActorLikesError::Unknown(v.into_static())
108
+
}
79
109
}
80
110
}
81
111
}
+30
-7
crates/jacquard-api/src/app_bsky/feed/get_feed.rs
+30
-7
crates/jacquard-api/src/app_bsky/feed/get_feed.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetFeed<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
13
13
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
14
14
#[serde(borrow)]
15
15
pub feed: jacquard_common::types::string::AtUri<'a>,
16
+
///(default: 50, min: 1, max: 100)
16
17
#[serde(skip_serializing_if = "std::option::Option::is_none")]
17
18
pub limit: std::option::Option<i64>,
18
19
}
19
20
20
-
impl Default for GetFeed<'_> {
21
-
fn default() -> Self {
22
-
Self {
23
-
cursor: Default::default(),
24
-
feed: Default::default(),
25
-
limit: Some(50i64),
21
+
impl jacquard_common::IntoStatic for GetFeed<'_> {
22
+
type Output = GetFeed<'static>;
23
+
fn into_static(self) -> Self::Output {
24
+
GetFeed {
25
+
cursor: self.cursor.into_static(),
26
+
feed: self.feed.into_static(),
27
+
limit: self.limit.into_static(),
26
28
}
27
29
}
28
30
}
···
38
40
pub feed: Vec<crate::app_bsky::feed::FeedViewPost<'a>>,
39
41
}
40
42
43
+
impl jacquard_common::IntoStatic for GetFeedOutput<'_> {
44
+
type Output = GetFeedOutput<'static>;
45
+
fn into_static(self) -> Self::Output {
46
+
GetFeedOutput {
47
+
cursor: self.cursor.into_static(),
48
+
feed: self.feed.into_static(),
49
+
extra_data: self.extra_data.into_static(),
50
+
}
51
+
}
52
+
}
53
+
41
54
#[jacquard_derive::open_union]
42
55
#[derive(
43
56
serde::Serialize,
···
67
80
Ok(())
68
81
}
69
82
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
83
+
}
84
+
}
85
+
}
86
+
87
+
impl jacquard_common::IntoStatic for GetFeedError<'_> {
88
+
type Output = GetFeedError<'static>;
89
+
fn into_static(self) -> Self::Output {
90
+
match self {
91
+
GetFeedError::UnknownFeed(v) => GetFeedError::UnknownFeed(v.into_static()),
92
+
GetFeedError::Unknown(v) => GetFeedError::Unknown(v.into_static()),
70
93
}
71
94
}
72
95
}
+22
-1
crates/jacquard-api/src/app_bsky/feed/get_feed_generator.rs
+22
-1
crates/jacquard-api/src/app_bsky/feed/get_feed_generator.rs
···
12
12
pub feed: jacquard_common::types::string::AtUri<'a>,
13
13
}
14
14
15
+
impl jacquard_common::IntoStatic for GetFeedGenerator<'_> {
16
+
type Output = GetFeedGenerator<'static>;
17
+
fn into_static(self) -> Self::Output {
18
+
GetFeedGenerator {
19
+
feed: self.feed.into_static(),
20
+
}
21
+
}
22
+
}
23
+
15
24
#[jacquard_derive::lexicon]
16
25
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
26
#[serde(rename_all = "camelCase")]
···
24
33
pub view: crate::app_bsky::feed::GeneratorView<'a>,
25
34
}
26
35
36
+
impl jacquard_common::IntoStatic for GetFeedGeneratorOutput<'_> {
37
+
type Output = GetFeedGeneratorOutput<'static>;
38
+
fn into_static(self) -> Self::Output {
39
+
GetFeedGeneratorOutput {
40
+
is_online: self.is_online.into_static(),
41
+
is_valid: self.is_valid.into_static(),
42
+
view: self.view.into_static(),
43
+
extra_data: self.extra_data.into_static(),
44
+
}
45
+
}
46
+
}
47
+
27
48
impl jacquard_common::types::xrpc::XrpcRequest for GetFeedGenerator<'_> {
28
49
const NSID: &'static str = "app.bsky.feed.getFeedGenerator";
29
50
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
30
51
const OUTPUT_ENCODING: &'static str = "application/json";
31
52
type Output<'de> = GetFeedGeneratorOutput<'de>;
32
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
53
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
33
54
}
+20
-1
crates/jacquard-api/src/app_bsky/feed/get_feed_generators.rs
+20
-1
crates/jacquard-api/src/app_bsky/feed/get_feed_generators.rs
···
12
12
pub feeds: Vec<jacquard_common::types::string::AtUri<'a>>,
13
13
}
14
14
15
+
impl jacquard_common::IntoStatic for GetFeedGenerators<'_> {
16
+
type Output = GetFeedGenerators<'static>;
17
+
fn into_static(self) -> Self::Output {
18
+
GetFeedGenerators {
19
+
feeds: self.feeds.into_static(),
20
+
}
21
+
}
22
+
}
23
+
15
24
#[jacquard_derive::lexicon]
16
25
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
26
#[serde(rename_all = "camelCase")]
···
20
29
pub feeds: Vec<crate::app_bsky::feed::GeneratorView<'a>>,
21
30
}
22
31
32
+
impl jacquard_common::IntoStatic for GetFeedGeneratorsOutput<'_> {
33
+
type Output = GetFeedGeneratorsOutput<'static>;
34
+
fn into_static(self) -> Self::Output {
35
+
GetFeedGeneratorsOutput {
36
+
feeds: self.feeds.into_static(),
37
+
extra_data: self.extra_data.into_static(),
38
+
}
39
+
}
40
+
}
41
+
23
42
impl jacquard_common::types::xrpc::XrpcRequest for GetFeedGenerators<'_> {
24
43
const NSID: &'static str = "app.bsky.feed.getFeedGenerators";
25
44
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
26
45
const OUTPUT_ENCODING: &'static str = "application/json";
27
46
type Output<'de> = GetFeedGeneratorsOutput<'de>;
28
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
47
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
29
48
}
+35
-7
crates/jacquard-api/src/app_bsky/feed/get_feed_skeleton.rs
+35
-7
crates/jacquard-api/src/app_bsky/feed/get_feed_skeleton.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetFeedSkeleton<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
13
13
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
14
14
#[serde(borrow)]
15
15
pub feed: jacquard_common::types::string::AtUri<'a>,
16
+
///(default: 50, min: 1, max: 100)
16
17
#[serde(skip_serializing_if = "std::option::Option::is_none")]
17
18
pub limit: std::option::Option<i64>,
18
19
}
19
20
20
-
impl Default for GetFeedSkeleton<'_> {
21
-
fn default() -> Self {
22
-
Self {
23
-
cursor: Default::default(),
24
-
feed: Default::default(),
25
-
limit: Some(50i64),
21
+
impl jacquard_common::IntoStatic for GetFeedSkeleton<'_> {
22
+
type Output = GetFeedSkeleton<'static>;
23
+
fn into_static(self) -> Self::Output {
24
+
GetFeedSkeleton {
25
+
cursor: self.cursor.into_static(),
26
+
feed: self.feed.into_static(),
27
+
limit: self.limit.into_static(),
26
28
}
27
29
}
28
30
}
···
42
44
pub req_id: std::option::Option<jacquard_common::CowStr<'a>>,
43
45
}
44
46
47
+
impl jacquard_common::IntoStatic for GetFeedSkeletonOutput<'_> {
48
+
type Output = GetFeedSkeletonOutput<'static>;
49
+
fn into_static(self) -> Self::Output {
50
+
GetFeedSkeletonOutput {
51
+
cursor: self.cursor.into_static(),
52
+
feed: self.feed.into_static(),
53
+
req_id: self.req_id.into_static(),
54
+
extra_data: self.extra_data.into_static(),
55
+
}
56
+
}
57
+
}
58
+
45
59
#[jacquard_derive::open_union]
46
60
#[derive(
47
61
serde::Serialize,
···
71
85
Ok(())
72
86
}
73
87
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
88
+
}
89
+
}
90
+
}
91
+
92
+
impl jacquard_common::IntoStatic for GetFeedSkeletonError<'_> {
93
+
type Output = GetFeedSkeletonError<'static>;
94
+
fn into_static(self) -> Self::Output {
95
+
match self {
96
+
GetFeedSkeletonError::UnknownFeed(v) => {
97
+
GetFeedSkeletonError::UnknownFeed(v.into_static())
98
+
}
99
+
GetFeedSkeletonError::Unknown(v) => {
100
+
GetFeedSkeletonError::Unknown(v.into_static())
101
+
}
74
102
}
75
103
}
76
104
}
+36
-9
crates/jacquard-api/src/app_bsky/feed/get_likes.rs
+36
-9
crates/jacquard-api/src/app_bsky/feed/get_likes.rs
···
15
15
pub indexed_at: jacquard_common::types::string::Datetime,
16
16
}
17
17
18
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
18
+
impl jacquard_common::IntoStatic for Like<'_> {
19
+
type Output = Like<'static>;
20
+
fn into_static(self) -> Self::Output {
21
+
Like {
22
+
actor: self.actor.into_static(),
23
+
created_at: self.created_at.into_static(),
24
+
indexed_at: self.indexed_at.into_static(),
25
+
extra_data: self.extra_data.into_static(),
26
+
}
27
+
}
28
+
}
29
+
30
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
19
31
#[serde(rename_all = "camelCase")]
20
32
pub struct GetLikes<'a> {
21
33
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
24
36
#[serde(skip_serializing_if = "std::option::Option::is_none")]
25
37
#[serde(borrow)]
26
38
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
39
+
///(default: 50, min: 1, max: 100)
27
40
#[serde(skip_serializing_if = "std::option::Option::is_none")]
28
41
pub limit: std::option::Option<i64>,
29
42
#[serde(borrow)]
30
43
pub uri: jacquard_common::types::string::AtUri<'a>,
31
44
}
32
45
33
-
impl Default for GetLikes<'_> {
34
-
fn default() -> Self {
35
-
Self {
36
-
cid: Default::default(),
37
-
cursor: Default::default(),
38
-
limit: Some(50i64),
39
-
uri: Default::default(),
46
+
impl jacquard_common::IntoStatic for GetLikes<'_> {
47
+
type Output = GetLikes<'static>;
48
+
fn into_static(self) -> Self::Output {
49
+
GetLikes {
50
+
cid: self.cid.into_static(),
51
+
cursor: self.cursor.into_static(),
52
+
limit: self.limit.into_static(),
53
+
uri: self.uri.into_static(),
40
54
}
41
55
}
42
56
}
···
57
71
pub uri: jacquard_common::types::string::AtUri<'a>,
58
72
}
59
73
74
+
impl jacquard_common::IntoStatic for GetLikesOutput<'_> {
75
+
type Output = GetLikesOutput<'static>;
76
+
fn into_static(self) -> Self::Output {
77
+
GetLikesOutput {
78
+
cid: self.cid.into_static(),
79
+
cursor: self.cursor.into_static(),
80
+
likes: self.likes.into_static(),
81
+
uri: self.uri.into_static(),
82
+
extra_data: self.extra_data.into_static(),
83
+
}
84
+
}
85
+
}
86
+
60
87
impl jacquard_common::types::xrpc::XrpcRequest for GetLikes<'_> {
61
88
const NSID: &'static str = "app.bsky.feed.getLikes";
62
89
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
63
90
const OUTPUT_ENCODING: &'static str = "application/json";
64
91
type Output<'de> = GetLikesOutput<'de>;
65
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
92
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
66
93
}
+32
-7
crates/jacquard-api/src/app_bsky/feed/get_list_feed.rs
+32
-7
crates/jacquard-api/src/app_bsky/feed/get_list_feed.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetListFeed<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
12
#[serde(borrow)]
13
13
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
14
+
///(default: 50, min: 1, max: 100)
14
15
#[serde(skip_serializing_if = "std::option::Option::is_none")]
15
16
pub limit: std::option::Option<i64>,
16
17
#[serde(borrow)]
17
18
pub list: jacquard_common::types::string::AtUri<'a>,
18
19
}
19
20
20
-
impl Default for GetListFeed<'_> {
21
-
fn default() -> Self {
22
-
Self {
23
-
cursor: Default::default(),
24
-
limit: Some(50i64),
25
-
list: Default::default(),
21
+
impl jacquard_common::IntoStatic for GetListFeed<'_> {
22
+
type Output = GetListFeed<'static>;
23
+
fn into_static(self) -> Self::Output {
24
+
GetListFeed {
25
+
cursor: self.cursor.into_static(),
26
+
limit: self.limit.into_static(),
27
+
list: self.list.into_static(),
26
28
}
27
29
}
28
30
}
···
38
40
pub feed: Vec<crate::app_bsky::feed::FeedViewPost<'a>>,
39
41
}
40
42
43
+
impl jacquard_common::IntoStatic for GetListFeedOutput<'_> {
44
+
type Output = GetListFeedOutput<'static>;
45
+
fn into_static(self) -> Self::Output {
46
+
GetListFeedOutput {
47
+
cursor: self.cursor.into_static(),
48
+
feed: self.feed.into_static(),
49
+
extra_data: self.extra_data.into_static(),
50
+
}
51
+
}
52
+
}
53
+
41
54
#[jacquard_derive::open_union]
42
55
#[derive(
43
56
serde::Serialize,
···
67
80
Ok(())
68
81
}
69
82
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
83
+
}
84
+
}
85
+
}
86
+
87
+
impl jacquard_common::IntoStatic for GetListFeedError<'_> {
88
+
type Output = GetListFeedError<'static>;
89
+
fn into_static(self) -> Self::Output {
90
+
match self {
91
+
GetListFeedError::UnknownList(v) => {
92
+
GetListFeedError::UnknownList(v.into_static())
93
+
}
94
+
GetListFeedError::Unknown(v) => GetListFeedError::Unknown(v.into_static()),
70
95
}
71
96
}
72
97
}
+55
-7
crates/jacquard-api/src/app_bsky/feed/get_post_thread.rs
+55
-7
crates/jacquard-api/src/app_bsky/feed/get_post_thread.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetPostThread<'a> {
11
+
///(default: 6, min: 0, max: 1000)
11
12
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
13
pub depth: std::option::Option<i64>,
14
+
///(default: 80, min: 0, max: 1000)
13
15
#[serde(skip_serializing_if = "std::option::Option::is_none")]
14
16
pub parent_height: std::option::Option<i64>,
15
17
#[serde(borrow)]
16
18
pub uri: jacquard_common::types::string::AtUri<'a>,
17
19
}
18
20
19
-
impl Default for GetPostThread<'_> {
20
-
fn default() -> Self {
21
-
Self {
22
-
depth: Some(6i64),
23
-
parent_height: Some(80i64),
24
-
uri: Default::default(),
21
+
impl jacquard_common::IntoStatic for GetPostThread<'_> {
22
+
type Output = GetPostThread<'static>;
23
+
fn into_static(self) -> Self::Output {
24
+
GetPostThread {
25
+
depth: self.depth.into_static(),
26
+
parent_height: self.parent_height.into_static(),
27
+
uri: self.uri.into_static(),
25
28
}
26
29
}
27
30
}
···
50
53
DefsBlockedPost(Box<crate::app_bsky::feed::BlockedPost<'a>>),
51
54
}
52
55
56
+
impl jacquard_common::IntoStatic for GetPostThreadOutputRecordThread<'_> {
57
+
type Output = GetPostThreadOutputRecordThread<'static>;
58
+
fn into_static(self) -> Self::Output {
59
+
match self {
60
+
GetPostThreadOutputRecordThread::DefsThreadViewPost(v) => {
61
+
GetPostThreadOutputRecordThread::DefsThreadViewPost(v.into_static())
62
+
}
63
+
GetPostThreadOutputRecordThread::DefsNotFoundPost(v) => {
64
+
GetPostThreadOutputRecordThread::DefsNotFoundPost(v.into_static())
65
+
}
66
+
GetPostThreadOutputRecordThread::DefsBlockedPost(v) => {
67
+
GetPostThreadOutputRecordThread::DefsBlockedPost(v.into_static())
68
+
}
69
+
GetPostThreadOutputRecordThread::Unknown(v) => {
70
+
GetPostThreadOutputRecordThread::Unknown(v.into_static())
71
+
}
72
+
}
73
+
}
74
+
}
75
+
76
+
impl jacquard_common::IntoStatic for GetPostThreadOutput<'_> {
77
+
type Output = GetPostThreadOutput<'static>;
78
+
fn into_static(self) -> Self::Output {
79
+
GetPostThreadOutput {
80
+
thread: self.thread.into_static(),
81
+
threadgate: self.threadgate.into_static(),
82
+
extra_data: self.extra_data.into_static(),
83
+
}
84
+
}
85
+
}
86
+
53
87
#[jacquard_derive::open_union]
54
88
#[derive(
55
89
serde::Serialize,
···
79
113
Ok(())
80
114
}
81
115
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
116
+
}
117
+
}
118
+
}
119
+
120
+
impl jacquard_common::IntoStatic for GetPostThreadError<'_> {
121
+
type Output = GetPostThreadError<'static>;
122
+
fn into_static(self) -> Self::Output {
123
+
match self {
124
+
GetPostThreadError::NotFound(v) => {
125
+
GetPostThreadError::NotFound(v.into_static())
126
+
}
127
+
GetPostThreadError::Unknown(v) => {
128
+
GetPostThreadError::Unknown(v.into_static())
129
+
}
82
130
}
83
131
}
84
132
}
+20
-1
crates/jacquard-api/src/app_bsky/feed/get_posts.rs
+20
-1
crates/jacquard-api/src/app_bsky/feed/get_posts.rs
···
12
12
pub uris: Vec<jacquard_common::types::string::AtUri<'a>>,
13
13
}
14
14
15
+
impl jacquard_common::IntoStatic for GetPosts<'_> {
16
+
type Output = GetPosts<'static>;
17
+
fn into_static(self) -> Self::Output {
18
+
GetPosts {
19
+
uris: self.uris.into_static(),
20
+
}
21
+
}
22
+
}
23
+
15
24
#[jacquard_derive::lexicon]
16
25
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
26
#[serde(rename_all = "camelCase")]
···
20
29
pub posts: Vec<crate::app_bsky::feed::PostView<'a>>,
21
30
}
22
31
32
+
impl jacquard_common::IntoStatic for GetPostsOutput<'_> {
33
+
type Output = GetPostsOutput<'static>;
34
+
fn into_static(self) -> Self::Output {
35
+
GetPostsOutput {
36
+
posts: self.posts.into_static(),
37
+
extra_data: self.extra_data.into_static(),
38
+
}
39
+
}
40
+
}
41
+
23
42
impl jacquard_common::types::xrpc::XrpcRequest for GetPosts<'_> {
24
43
const NSID: &'static str = "app.bsky.feed.getPosts";
25
44
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
26
45
const OUTPUT_ENCODING: &'static str = "application/json";
27
46
type Output<'de> = GetPostsOutput<'de>;
28
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
47
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
29
48
}
+24
-9
crates/jacquard-api/src/app_bsky/feed/get_quotes.rs
+24
-9
crates/jacquard-api/src/app_bsky/feed/get_quotes.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetQuotes<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
14
14
#[serde(skip_serializing_if = "std::option::Option::is_none")]
15
15
#[serde(borrow)]
16
16
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
17
+
///(default: 50, min: 1, max: 100)
17
18
#[serde(skip_serializing_if = "std::option::Option::is_none")]
18
19
pub limit: std::option::Option<i64>,
19
20
#[serde(borrow)]
20
21
pub uri: jacquard_common::types::string::AtUri<'a>,
21
22
}
22
23
23
-
impl Default for GetQuotes<'_> {
24
-
fn default() -> Self {
25
-
Self {
26
-
cid: Default::default(),
27
-
cursor: Default::default(),
28
-
limit: Some(50i64),
29
-
uri: Default::default(),
24
+
impl jacquard_common::IntoStatic for GetQuotes<'_> {
25
+
type Output = GetQuotes<'static>;
26
+
fn into_static(self) -> Self::Output {
27
+
GetQuotes {
28
+
cid: self.cid.into_static(),
29
+
cursor: self.cursor.into_static(),
30
+
limit: self.limit.into_static(),
31
+
uri: self.uri.into_static(),
30
32
}
31
33
}
32
34
}
···
47
49
pub uri: jacquard_common::types::string::AtUri<'a>,
48
50
}
49
51
52
+
impl jacquard_common::IntoStatic for GetQuotesOutput<'_> {
53
+
type Output = GetQuotesOutput<'static>;
54
+
fn into_static(self) -> Self::Output {
55
+
GetQuotesOutput {
56
+
cid: self.cid.into_static(),
57
+
cursor: self.cursor.into_static(),
58
+
posts: self.posts.into_static(),
59
+
uri: self.uri.into_static(),
60
+
extra_data: self.extra_data.into_static(),
61
+
}
62
+
}
63
+
}
64
+
50
65
impl jacquard_common::types::xrpc::XrpcRequest for GetQuotes<'_> {
51
66
const NSID: &'static str = "app.bsky.feed.getQuotes";
52
67
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
53
68
const OUTPUT_ENCODING: &'static str = "application/json";
54
69
type Output<'de> = GetQuotesOutput<'de>;
55
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
70
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
56
71
}
+24
-9
crates/jacquard-api/src/app_bsky/feed/get_reposted_by.rs
+24
-9
crates/jacquard-api/src/app_bsky/feed/get_reposted_by.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetRepostedBy<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
14
14
#[serde(skip_serializing_if = "std::option::Option::is_none")]
15
15
#[serde(borrow)]
16
16
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
17
+
///(default: 50, min: 1, max: 100)
17
18
#[serde(skip_serializing_if = "std::option::Option::is_none")]
18
19
pub limit: std::option::Option<i64>,
19
20
#[serde(borrow)]
20
21
pub uri: jacquard_common::types::string::AtUri<'a>,
21
22
}
22
23
23
-
impl Default for GetRepostedBy<'_> {
24
-
fn default() -> Self {
25
-
Self {
26
-
cid: Default::default(),
27
-
cursor: Default::default(),
28
-
limit: Some(50i64),
29
-
uri: Default::default(),
24
+
impl jacquard_common::IntoStatic for GetRepostedBy<'_> {
25
+
type Output = GetRepostedBy<'static>;
26
+
fn into_static(self) -> Self::Output {
27
+
GetRepostedBy {
28
+
cid: self.cid.into_static(),
29
+
cursor: self.cursor.into_static(),
30
+
limit: self.limit.into_static(),
31
+
uri: self.uri.into_static(),
30
32
}
31
33
}
32
34
}
···
47
49
pub uri: jacquard_common::types::string::AtUri<'a>,
48
50
}
49
51
52
+
impl jacquard_common::IntoStatic for GetRepostedByOutput<'_> {
53
+
type Output = GetRepostedByOutput<'static>;
54
+
fn into_static(self) -> Self::Output {
55
+
GetRepostedByOutput {
56
+
cid: self.cid.into_static(),
57
+
cursor: self.cursor.into_static(),
58
+
reposted_by: self.reposted_by.into_static(),
59
+
uri: self.uri.into_static(),
60
+
extra_data: self.extra_data.into_static(),
61
+
}
62
+
}
63
+
}
64
+
50
65
impl jacquard_common::types::xrpc::XrpcRequest for GetRepostedBy<'_> {
51
66
const NSID: &'static str = "app.bsky.feed.getRepostedBy";
52
67
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
53
68
const OUTPUT_ENCODING: &'static str = "application/json";
54
69
type Output<'de> = GetRepostedByOutput<'de>;
55
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
70
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
56
71
}
+23
-9
crates/jacquard-api/src/app_bsky/feed/get_suggested_feeds.rs
+23
-9
crates/jacquard-api/src/app_bsky/feed/get_suggested_feeds.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetSuggestedFeeds<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
12
#[serde(borrow)]
13
13
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
14
+
///(default: 50, min: 1, max: 100)
14
15
#[serde(skip_serializing_if = "std::option::Option::is_none")]
15
16
pub limit: std::option::Option<i64>,
16
17
}
17
18
18
-
impl Default for GetSuggestedFeeds<'_> {
19
-
fn default() -> Self {
20
-
Self {
21
-
cursor: Default::default(),
22
-
limit: Some(50i64),
19
+
impl jacquard_common::IntoStatic for GetSuggestedFeeds<'_> {
20
+
type Output = GetSuggestedFeeds<'static>;
21
+
fn into_static(self) -> Self::Output {
22
+
GetSuggestedFeeds {
23
+
cursor: self.cursor.into_static(),
24
+
limit: self.limit.into_static(),
23
25
}
24
26
}
25
27
}
···
35
37
pub feeds: Vec<crate::app_bsky::feed::GeneratorView<'a>>,
36
38
}
37
39
40
+
impl jacquard_common::IntoStatic for GetSuggestedFeedsOutput<'_> {
41
+
type Output = GetSuggestedFeedsOutput<'static>;
42
+
fn into_static(self) -> Self::Output {
43
+
GetSuggestedFeedsOutput {
44
+
cursor: self.cursor.into_static(),
45
+
feeds: self.feeds.into_static(),
46
+
extra_data: self.extra_data.into_static(),
47
+
}
48
+
}
49
+
}
50
+
38
51
impl jacquard_common::types::xrpc::XrpcRequest for GetSuggestedFeeds<'_> {
39
52
const NSID: &'static str = "app.bsky.feed.getSuggestedFeeds";
40
-
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
53
+
const METHOD: jacquard_common::types::xrpc::XrpcMethod =
54
+
jacquard_common::types::xrpc::XrpcMethod::Query;
41
55
const OUTPUT_ENCODING: &'static str = "application/json";
42
56
type Output<'de> = GetSuggestedFeedsOutput<'de>;
43
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
44
-
}
57
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
58
+
}
+21
-8
crates/jacquard-api/src/app_bsky/feed/get_timeline.rs
+21
-8
crates/jacquard-api/src/app_bsky/feed/get_timeline.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetTimeline<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
14
14
#[serde(skip_serializing_if = "std::option::Option::is_none")]
15
15
#[serde(borrow)]
16
16
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
17
+
///(default: 50, min: 1, max: 100)
17
18
#[serde(skip_serializing_if = "std::option::Option::is_none")]
18
19
pub limit: std::option::Option<i64>,
19
20
}
20
21
21
-
impl Default for GetTimeline<'_> {
22
-
fn default() -> Self {
23
-
Self {
24
-
algorithm: Default::default(),
25
-
cursor: Default::default(),
26
-
limit: Some(50i64),
22
+
impl jacquard_common::IntoStatic for GetTimeline<'_> {
23
+
type Output = GetTimeline<'static>;
24
+
fn into_static(self) -> Self::Output {
25
+
GetTimeline {
26
+
algorithm: self.algorithm.into_static(),
27
+
cursor: self.cursor.into_static(),
28
+
limit: self.limit.into_static(),
27
29
}
28
30
}
29
31
}
···
39
41
pub feed: Vec<crate::app_bsky::feed::FeedViewPost<'a>>,
40
42
}
41
43
44
+
impl jacquard_common::IntoStatic for GetTimelineOutput<'_> {
45
+
type Output = GetTimelineOutput<'static>;
46
+
fn into_static(self) -> Self::Output {
47
+
GetTimelineOutput {
48
+
cursor: self.cursor.into_static(),
49
+
feed: self.feed.into_static(),
50
+
extra_data: self.extra_data.into_static(),
51
+
}
52
+
}
53
+
}
54
+
42
55
impl jacquard_common::types::xrpc::XrpcRequest for GetTimeline<'_> {
43
56
const NSID: &'static str = "app.bsky.feed.getTimeline";
44
57
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
45
58
const OUTPUT_ENCODING: &'static str = "application/json";
46
59
type Output<'de> = GetTimelineOutput<'de>;
47
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
60
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
48
61
}
+12
crates/jacquard-api/src/app_bsky/feed/like.rs
+12
crates/jacquard-api/src/app_bsky/feed/like.rs
···
20
20
21
21
impl jacquard_common::types::collection::Collection for Like<'_> {
22
22
const NSID: &'static str = "app.bsky.feed.like";
23
+
}
24
+
25
+
impl jacquard_common::IntoStatic for Like<'_> {
26
+
type Output = Like<'static>;
27
+
fn into_static(self) -> Self::Output {
28
+
Like {
29
+
created_at: self.created_at.into_static(),
30
+
subject: self.subject.into_static(),
31
+
via: self.via.into_static(),
32
+
extra_data: self.extra_data.into_static(),
33
+
}
34
+
}
23
35
}
+80
crates/jacquard-api/src/app_bsky/feed/post.rs
+80
crates/jacquard-api/src/app_bsky/feed/post.rs
···
19
19
pub value: jacquard_common::CowStr<'a>,
20
20
}
21
21
22
+
impl jacquard_common::IntoStatic for Entity<'_> {
23
+
type Output = Entity<'static>;
24
+
fn into_static(self) -> Self::Output {
25
+
Entity {
26
+
index: self.index.into_static(),
27
+
r#type: self.r#type.into_static(),
28
+
value: self.value.into_static(),
29
+
extra_data: self.extra_data.into_static(),
30
+
}
31
+
}
32
+
}
33
+
22
34
///Record containing a Bluesky post.
23
35
#[jacquard_derive::lexicon]
24
36
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
73
85
RecordWithMedia(Box<crate::app_bsky::embed::record_with_media::RecordWithMedia<'a>>),
74
86
}
75
87
88
+
impl jacquard_common::IntoStatic for PostRecordEmbed<'_> {
89
+
type Output = PostRecordEmbed<'static>;
90
+
fn into_static(self) -> Self::Output {
91
+
match self {
92
+
PostRecordEmbed::Images(v) => PostRecordEmbed::Images(v.into_static()),
93
+
PostRecordEmbed::Video(v) => PostRecordEmbed::Video(v.into_static()),
94
+
PostRecordEmbed::External(v) => PostRecordEmbed::External(v.into_static()),
95
+
PostRecordEmbed::Record(v) => PostRecordEmbed::Record(v.into_static()),
96
+
PostRecordEmbed::RecordWithMedia(v) => {
97
+
PostRecordEmbed::RecordWithMedia(v.into_static())
98
+
}
99
+
PostRecordEmbed::Unknown(v) => PostRecordEmbed::Unknown(v.into_static()),
100
+
}
101
+
}
102
+
}
103
+
76
104
#[jacquard_derive::open_union]
77
105
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
78
106
#[serde(tag = "$type")]
···
80
108
pub enum PostRecordLabels<'a> {
81
109
#[serde(rename = "com.atproto.label.defs#selfLabels")]
82
110
DefsSelfLabels(Box<crate::com_atproto::label::SelfLabels<'a>>),
111
+
}
112
+
113
+
impl jacquard_common::IntoStatic for PostRecordLabels<'_> {
114
+
type Output = PostRecordLabels<'static>;
115
+
fn into_static(self) -> Self::Output {
116
+
match self {
117
+
PostRecordLabels::DefsSelfLabels(v) => {
118
+
PostRecordLabels::DefsSelfLabels(v.into_static())
119
+
}
120
+
PostRecordLabels::Unknown(v) => PostRecordLabels::Unknown(v.into_static()),
121
+
}
122
+
}
83
123
}
84
124
85
125
impl jacquard_common::types::collection::Collection for Post<'_> {
86
126
const NSID: &'static str = "app.bsky.feed.post";
87
127
}
88
128
129
+
impl jacquard_common::IntoStatic for Post<'_> {
130
+
type Output = Post<'static>;
131
+
fn into_static(self) -> Self::Output {
132
+
Post {
133
+
created_at: self.created_at.into_static(),
134
+
embed: self.embed.into_static(),
135
+
entities: self.entities.into_static(),
136
+
facets: self.facets.into_static(),
137
+
labels: self.labels.into_static(),
138
+
langs: self.langs.into_static(),
139
+
reply: self.reply.into_static(),
140
+
tags: self.tags.into_static(),
141
+
text: self.text.into_static(),
142
+
extra_data: self.extra_data.into_static(),
143
+
}
144
+
}
145
+
}
146
+
89
147
#[jacquard_derive::lexicon]
90
148
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
91
149
#[serde(rename_all = "camelCase")]
···
96
154
pub root: crate::com_atproto::repo::strong_ref::StrongRef<'a>,
97
155
}
98
156
157
+
impl jacquard_common::IntoStatic for ReplyRef<'_> {
158
+
type Output = ReplyRef<'static>;
159
+
fn into_static(self) -> Self::Output {
160
+
ReplyRef {
161
+
parent: self.parent.into_static(),
162
+
root: self.root.into_static(),
163
+
extra_data: self.extra_data.into_static(),
164
+
}
165
+
}
166
+
}
167
+
99
168
///Deprecated. Use app.bsky.richtext instead -- A text segment. Start is inclusive, end is exclusive. Indices are for utf16-encoded strings.
100
169
#[jacquard_derive::lexicon]
101
170
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
103
172
pub struct TextSlice<'a> {
104
173
pub end: i64,
105
174
pub start: i64,
175
+
}
176
+
177
+
impl jacquard_common::IntoStatic for TextSlice<'_> {
178
+
type Output = TextSlice<'static>;
179
+
fn into_static(self) -> Self::Output {
180
+
TextSlice {
181
+
end: self.end.into_static(),
182
+
start: self.start.into_static(),
183
+
extra_data: self.extra_data.into_static(),
184
+
}
185
+
}
106
186
}
+22
crates/jacquard-api/src/app_bsky/feed/postgate.rs
+22
crates/jacquard-api/src/app_bsky/feed/postgate.rs
···
10
10
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
11
11
#[serde(rename_all = "camelCase")]
12
12
pub struct DisableRule<'a> {}
13
+
impl jacquard_common::IntoStatic for DisableRule<'_> {
14
+
type Output = DisableRule<'static>;
15
+
fn into_static(self) -> Self::Output {
16
+
DisableRule {
17
+
extra_data: self.extra_data.into_static(),
18
+
}
19
+
}
20
+
}
21
+
13
22
///Record defining interaction rules for a post. The record key (rkey) of the postgate record must match the record key of the post, and that record must be in the same repository.
14
23
#[jacquard_derive::lexicon]
15
24
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
35
44
36
45
impl jacquard_common::types::collection::Collection for Postgate<'_> {
37
46
const NSID: &'static str = "app.bsky.feed.postgate";
47
+
}
48
+
49
+
impl jacquard_common::IntoStatic for Postgate<'_> {
50
+
type Output = Postgate<'static>;
51
+
fn into_static(self) -> Self::Output {
52
+
Postgate {
53
+
created_at: self.created_at.into_static(),
54
+
detached_embedding_uris: self.detached_embedding_uris.into_static(),
55
+
embedding_rules: self.embedding_rules.into_static(),
56
+
post: self.post.into_static(),
57
+
extra_data: self.extra_data.into_static(),
58
+
}
59
+
}
38
60
}
+12
crates/jacquard-api/src/app_bsky/feed/repost.rs
+12
crates/jacquard-api/src/app_bsky/feed/repost.rs
···
20
20
21
21
impl jacquard_common::types::collection::Collection for Repost<'_> {
22
22
const NSID: &'static str = "app.bsky.feed.repost";
23
+
}
24
+
25
+
impl jacquard_common::IntoStatic for Repost<'_> {
26
+
type Output = Repost<'static>;
27
+
fn into_static(self) -> Self::Output {
28
+
Repost {
29
+
created_at: self.created_at.into_static(),
30
+
subject: self.subject.into_static(),
31
+
via: self.via.into_static(),
32
+
extra_data: self.extra_data.into_static(),
33
+
}
34
+
}
23
35
}
+43
-16
crates/jacquard-api/src/app_bsky/feed/search_posts.rs
+43
-16
crates/jacquard-api/src/app_bsky/feed/search_posts.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct SearchPosts<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
19
19
pub domain: std::option::Option<jacquard_common::CowStr<'a>>,
20
20
#[serde(skip_serializing_if = "std::option::Option::is_none")]
21
21
pub lang: std::option::Option<jacquard_common::types::string::Language>,
22
+
///(default: 25, min: 1, max: 100)
22
23
#[serde(skip_serializing_if = "std::option::Option::is_none")]
23
24
pub limit: std::option::Option<i64>,
24
25
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
29
30
#[serde(skip_serializing_if = "std::option::Option::is_none")]
30
31
#[serde(borrow)]
31
32
pub since: std::option::Option<jacquard_common::CowStr<'a>>,
33
+
///(default: "latest")
32
34
#[serde(skip_serializing_if = "std::option::Option::is_none")]
33
35
#[serde(borrow)]
34
36
pub sort: std::option::Option<jacquard_common::CowStr<'a>>,
···
43
45
pub url: std::option::Option<jacquard_common::types::string::Uri<'a>>,
44
46
}
45
47
46
-
impl Default for SearchPosts<'_> {
47
-
fn default() -> Self {
48
-
Self {
49
-
author: Default::default(),
50
-
cursor: Default::default(),
51
-
domain: Default::default(),
52
-
lang: Default::default(),
53
-
limit: Some(25i64),
54
-
mentions: Default::default(),
55
-
q: Default::default(),
56
-
since: Default::default(),
57
-
sort: Some(jacquard_common::CowStr::from("latest")),
58
-
tag: Default::default(),
59
-
until: Default::default(),
60
-
url: Default::default(),
48
+
impl jacquard_common::IntoStatic for SearchPosts<'_> {
49
+
type Output = SearchPosts<'static>;
50
+
fn into_static(self) -> Self::Output {
51
+
SearchPosts {
52
+
author: self.author.into_static(),
53
+
cursor: self.cursor.into_static(),
54
+
domain: self.domain.into_static(),
55
+
lang: self.lang.into_static(),
56
+
limit: self.limit.into_static(),
57
+
mentions: self.mentions.into_static(),
58
+
q: self.q.into_static(),
59
+
since: self.since.into_static(),
60
+
sort: self.sort.into_static(),
61
+
tag: self.tag.into_static(),
62
+
until: self.until.into_static(),
63
+
url: self.url.into_static(),
61
64
}
62
65
}
63
66
}
···
76
79
pub posts: Vec<crate::app_bsky::feed::PostView<'a>>,
77
80
}
78
81
82
+
impl jacquard_common::IntoStatic for SearchPostsOutput<'_> {
83
+
type Output = SearchPostsOutput<'static>;
84
+
fn into_static(self) -> Self::Output {
85
+
SearchPostsOutput {
86
+
cursor: self.cursor.into_static(),
87
+
hits_total: self.hits_total.into_static(),
88
+
posts: self.posts.into_static(),
89
+
extra_data: self.extra_data.into_static(),
90
+
}
91
+
}
92
+
}
93
+
79
94
#[jacquard_derive::open_union]
80
95
#[derive(
81
96
serde::Serialize,
···
105
120
Ok(())
106
121
}
107
122
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
123
+
}
124
+
}
125
+
}
126
+
127
+
impl jacquard_common::IntoStatic for SearchPostsError<'_> {
128
+
type Output = SearchPostsError<'static>;
129
+
fn into_static(self) -> Self::Output {
130
+
match self {
131
+
SearchPostsError::BadQueryString(v) => {
132
+
SearchPostsError::BadQueryString(v.into_static())
133
+
}
134
+
SearchPostsError::Unknown(v) => SearchPostsError::Unknown(v.into_static()),
108
135
}
109
136
}
110
137
}
+20
-1
crates/jacquard-api/src/app_bsky/feed/send_interactions.rs
+20
-1
crates/jacquard-api/src/app_bsky/feed/send_interactions.rs
···
13
13
pub interactions: Vec<crate::app_bsky::feed::Interaction<'a>>,
14
14
}
15
15
16
+
impl jacquard_common::IntoStatic for SendInteractions<'_> {
17
+
type Output = SendInteractions<'static>;
18
+
fn into_static(self) -> Self::Output {
19
+
SendInteractions {
20
+
interactions: self.interactions.into_static(),
21
+
extra_data: self.extra_data.into_static(),
22
+
}
23
+
}
24
+
}
25
+
16
26
#[jacquard_derive::lexicon]
17
27
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
18
28
#[serde(rename_all = "camelCase")]
19
29
pub struct SendInteractionsOutput<'a> {}
30
+
impl jacquard_common::IntoStatic for SendInteractionsOutput<'_> {
31
+
type Output = SendInteractionsOutput<'static>;
32
+
fn into_static(self) -> Self::Output {
33
+
SendInteractionsOutput {
34
+
extra_data: self.extra_data.into_static(),
35
+
}
36
+
}
37
+
}
38
+
20
39
impl jacquard_common::types::xrpc::XrpcRequest for SendInteractions<'_> {
21
40
const NSID: &'static str = "app.bsky.feed.sendInteractions";
22
41
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
24
43
);
25
44
const OUTPUT_ENCODING: &'static str = "application/json";
26
45
type Output<'de> = SendInteractionsOutput<'de>;
27
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
46
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
28
47
}
+50
-1
crates/jacquard-api/src/app_bsky/feed/threadgate.rs
+50
-1
crates/jacquard-api/src/app_bsky/feed/threadgate.rs
···
10
10
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
11
11
#[serde(rename_all = "camelCase")]
12
12
pub struct FollowerRule<'a> {}
13
+
impl jacquard_common::IntoStatic for FollowerRule<'_> {
14
+
type Output = FollowerRule<'static>;
15
+
fn into_static(self) -> Self::Output {
16
+
FollowerRule {
17
+
extra_data: self.extra_data.into_static(),
18
+
}
19
+
}
20
+
}
21
+
13
22
///Allow replies from actors you follow.
14
23
#[jacquard_derive::lexicon]
15
24
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
16
25
#[serde(rename_all = "camelCase")]
17
26
pub struct FollowingRule<'a> {}
27
+
impl jacquard_common::IntoStatic for FollowingRule<'_> {
28
+
type Output = FollowingRule<'static>;
29
+
fn into_static(self) -> Self::Output {
30
+
FollowingRule {
31
+
extra_data: self.extra_data.into_static(),
32
+
}
33
+
}
34
+
}
35
+
18
36
///Allow replies from actors on a list.
19
37
#[jacquard_derive::lexicon]
20
38
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
24
42
pub list: jacquard_common::types::string::AtUri<'a>,
25
43
}
26
44
45
+
impl jacquard_common::IntoStatic for ListRule<'_> {
46
+
type Output = ListRule<'static>;
47
+
fn into_static(self) -> Self::Output {
48
+
ListRule {
49
+
list: self.list.into_static(),
50
+
extra_data: self.extra_data.into_static(),
51
+
}
52
+
}
53
+
}
54
+
27
55
///Record defining interaction gating rules for a thread (aka, reply controls). The record key (rkey) of the threadgate record must match the record key of the thread's root post, and that record must be in the same repository.
28
56
#[jacquard_derive::lexicon]
29
57
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
49
77
const NSID: &'static str = "app.bsky.feed.threadgate";
50
78
}
51
79
80
+
impl jacquard_common::IntoStatic for Threadgate<'_> {
81
+
type Output = Threadgate<'static>;
82
+
fn into_static(self) -> Self::Output {
83
+
Threadgate {
84
+
allow: self.allow.into_static(),
85
+
created_at: self.created_at.into_static(),
86
+
hidden_replies: self.hidden_replies.into_static(),
87
+
post: self.post.into_static(),
88
+
extra_data: self.extra_data.into_static(),
89
+
}
90
+
}
91
+
}
92
+
52
93
///Allow replies from actors mentioned in your post.
53
94
#[jacquard_derive::lexicon]
54
95
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
55
96
#[serde(rename_all = "camelCase")]
56
-
pub struct MentionRule<'a> {}
97
+
pub struct MentionRule<'a> {}
98
+
impl jacquard_common::IntoStatic for MentionRule<'_> {
99
+
type Output = MentionRule<'static>;
100
+
fn into_static(self) -> Self::Output {
101
+
MentionRule {
102
+
extra_data: self.extra_data.into_static(),
103
+
}
104
+
}
105
+
}
+138
crates/jacquard-api/src/app_bsky/graph.rs
+138
crates/jacquard-api/src/app_bsky/graph.rs
···
46
46
pub uri: jacquard_common::types::string::AtUri<'a>,
47
47
}
48
48
49
+
impl jacquard_common::IntoStatic for ListItemView<'_> {
50
+
type Output = ListItemView<'static>;
51
+
fn into_static(self) -> Self::Output {
52
+
ListItemView {
53
+
subject: self.subject.into_static(),
54
+
uri: self.uri.into_static(),
55
+
extra_data: self.extra_data.into_static(),
56
+
}
57
+
}
58
+
}
59
+
49
60
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
50
61
pub enum ListPurpose<'a> {
51
62
AppBskyGraphDefsModlist,
···
115
126
}
116
127
}
117
128
129
+
impl jacquard_common::IntoStatic for ListPurpose<'_> {
130
+
type Output = ListPurpose<'static>;
131
+
fn into_static(self) -> Self::Output {
132
+
match self {
133
+
ListPurpose::AppBskyGraphDefsModlist => ListPurpose::AppBskyGraphDefsModlist,
134
+
ListPurpose::AppBskyGraphDefsCuratelist => {
135
+
ListPurpose::AppBskyGraphDefsCuratelist
136
+
}
137
+
ListPurpose::AppBskyGraphDefsReferencelist => {
138
+
ListPurpose::AppBskyGraphDefsReferencelist
139
+
}
140
+
ListPurpose::Other(v) => ListPurpose::Other(v.into_static()),
141
+
}
142
+
}
143
+
}
144
+
118
145
#[jacquard_derive::lexicon]
119
146
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
120
147
#[serde(rename_all = "camelCase")]
···
151
178
pub viewer: std::option::Option<crate::app_bsky::graph::ListViewerState<'a>>,
152
179
}
153
180
181
+
impl jacquard_common::IntoStatic for ListView<'_> {
182
+
type Output = ListView<'static>;
183
+
fn into_static(self) -> Self::Output {
184
+
ListView {
185
+
avatar: self.avatar.into_static(),
186
+
cid: self.cid.into_static(),
187
+
creator: self.creator.into_static(),
188
+
description: self.description.into_static(),
189
+
description_facets: self.description_facets.into_static(),
190
+
indexed_at: self.indexed_at.into_static(),
191
+
labels: self.labels.into_static(),
192
+
list_item_count: self.list_item_count.into_static(),
193
+
name: self.name.into_static(),
194
+
purpose: self.purpose.into_static(),
195
+
uri: self.uri.into_static(),
196
+
viewer: self.viewer.into_static(),
197
+
extra_data: self.extra_data.into_static(),
198
+
}
199
+
}
200
+
}
201
+
154
202
#[jacquard_derive::lexicon]
155
203
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
156
204
#[serde(rename_all = "camelCase")]
···
178
226
pub viewer: std::option::Option<crate::app_bsky::graph::ListViewerState<'a>>,
179
227
}
180
228
229
+
impl jacquard_common::IntoStatic for ListViewBasic<'_> {
230
+
type Output = ListViewBasic<'static>;
231
+
fn into_static(self) -> Self::Output {
232
+
ListViewBasic {
233
+
avatar: self.avatar.into_static(),
234
+
cid: self.cid.into_static(),
235
+
indexed_at: self.indexed_at.into_static(),
236
+
labels: self.labels.into_static(),
237
+
list_item_count: self.list_item_count.into_static(),
238
+
name: self.name.into_static(),
239
+
purpose: self.purpose.into_static(),
240
+
uri: self.uri.into_static(),
241
+
viewer: self.viewer.into_static(),
242
+
extra_data: self.extra_data.into_static(),
243
+
}
244
+
}
245
+
}
246
+
181
247
#[jacquard_derive::lexicon]
182
248
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
183
249
#[serde(rename_all = "camelCase")]
···
189
255
pub muted: std::option::Option<bool>,
190
256
}
191
257
258
+
impl jacquard_common::IntoStatic for ListViewerState<'_> {
259
+
type Output = ListViewerState<'static>;
260
+
fn into_static(self) -> Self::Output {
261
+
ListViewerState {
262
+
blocked: self.blocked.into_static(),
263
+
muted: self.muted.into_static(),
264
+
extra_data: self.extra_data.into_static(),
265
+
}
266
+
}
267
+
}
268
+
192
269
///indicates that a handle or DID could not be resolved
193
270
#[jacquard_derive::lexicon]
194
271
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
199
276
pub not_found: bool,
200
277
}
201
278
279
+
impl jacquard_common::IntoStatic for NotFoundActor<'_> {
280
+
type Output = NotFoundActor<'static>;
281
+
fn into_static(self) -> Self::Output {
282
+
NotFoundActor {
283
+
actor: self.actor.into_static(),
284
+
not_found: self.not_found.into_static(),
285
+
extra_data: self.extra_data.into_static(),
286
+
}
287
+
}
288
+
}
289
+
202
290
///lists the bi-directional graph relationships between one actor (not indicated in the object), and the target actors (the DID included in the object)
203
291
#[jacquard_derive::lexicon]
204
292
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
214
302
#[serde(skip_serializing_if = "std::option::Option::is_none")]
215
303
#[serde(borrow)]
216
304
pub following: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
305
+
}
306
+
307
+
impl jacquard_common::IntoStatic for Relationship<'_> {
308
+
type Output = Relationship<'static>;
309
+
fn into_static(self) -> Self::Output {
310
+
Relationship {
311
+
did: self.did.into_static(),
312
+
followed_by: self.followed_by.into_static(),
313
+
following: self.following.into_static(),
314
+
extra_data: self.extra_data.into_static(),
315
+
}
316
+
}
217
317
}
218
318
219
319
#[jacquard_derive::lexicon]
···
249
349
pub uri: jacquard_common::types::string::AtUri<'a>,
250
350
}
251
351
352
+
impl jacquard_common::IntoStatic for StarterPackView<'_> {
353
+
type Output = StarterPackView<'static>;
354
+
fn into_static(self) -> Self::Output {
355
+
StarterPackView {
356
+
cid: self.cid.into_static(),
357
+
creator: self.creator.into_static(),
358
+
feeds: self.feeds.into_static(),
359
+
indexed_at: self.indexed_at.into_static(),
360
+
joined_all_time_count: self.joined_all_time_count.into_static(),
361
+
joined_week_count: self.joined_week_count.into_static(),
362
+
labels: self.labels.into_static(),
363
+
list: self.list.into_static(),
364
+
list_items_sample: self.list_items_sample.into_static(),
365
+
record: self.record.into_static(),
366
+
uri: self.uri.into_static(),
367
+
extra_data: self.extra_data.into_static(),
368
+
}
369
+
}
370
+
}
371
+
252
372
#[jacquard_derive::lexicon]
253
373
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
254
374
#[serde(rename_all = "camelCase")]
···
271
391
pub record: jacquard_common::types::value::Data<'a>,
272
392
#[serde(borrow)]
273
393
pub uri: jacquard_common::types::string::AtUri<'a>,
394
+
}
395
+
396
+
impl jacquard_common::IntoStatic for StarterPackViewBasic<'_> {
397
+
type Output = StarterPackViewBasic<'static>;
398
+
fn into_static(self) -> Self::Output {
399
+
StarterPackViewBasic {
400
+
cid: self.cid.into_static(),
401
+
creator: self.creator.into_static(),
402
+
indexed_at: self.indexed_at.into_static(),
403
+
joined_all_time_count: self.joined_all_time_count.into_static(),
404
+
joined_week_count: self.joined_week_count.into_static(),
405
+
labels: self.labels.into_static(),
406
+
list_item_count: self.list_item_count.into_static(),
407
+
record: self.record.into_static(),
408
+
uri: self.uri.into_static(),
409
+
extra_data: self.extra_data.into_static(),
410
+
}
411
+
}
274
412
}
+11
crates/jacquard-api/src/app_bsky/graph/block.rs
+11
crates/jacquard-api/src/app_bsky/graph/block.rs
···
18
18
19
19
impl jacquard_common::types::collection::Collection for Block<'_> {
20
20
const NSID: &'static str = "app.bsky.graph.block";
21
+
}
22
+
23
+
impl jacquard_common::IntoStatic for Block<'_> {
24
+
type Output = Block<'static>;
25
+
fn into_static(self) -> Self::Output {
26
+
Block {
27
+
created_at: self.created_at.into_static(),
28
+
subject: self.subject.into_static(),
29
+
extra_data: self.extra_data.into_static(),
30
+
}
31
+
}
21
32
}
+11
crates/jacquard-api/src/app_bsky/graph/follow.rs
+11
crates/jacquard-api/src/app_bsky/graph/follow.rs
···
17
17
18
18
impl jacquard_common::types::collection::Collection for Follow<'_> {
19
19
const NSID: &'static str = "app.bsky.graph.follow";
20
+
}
21
+
22
+
impl jacquard_common::IntoStatic for Follow<'_> {
23
+
type Output = Follow<'static>;
24
+
fn into_static(self) -> Self::Output {
25
+
Follow {
26
+
created_at: self.created_at.into_static(),
27
+
subject: self.subject.into_static(),
28
+
extra_data: self.extra_data.into_static(),
29
+
}
30
+
}
20
31
}
+21
-8
crates/jacquard-api/src/app_bsky/graph/get_actor_starter_packs.rs
+21
-8
crates/jacquard-api/src/app_bsky/graph/get_actor_starter_packs.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetActorStarterPacks<'a> {
11
11
#[serde(borrow)]
···
13
13
#[serde(skip_serializing_if = "std::option::Option::is_none")]
14
14
#[serde(borrow)]
15
15
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
16
+
///(default: 50, min: 1, max: 100)
16
17
#[serde(skip_serializing_if = "std::option::Option::is_none")]
17
18
pub limit: std::option::Option<i64>,
18
19
}
19
20
20
-
impl Default for GetActorStarterPacks<'_> {
21
-
fn default() -> Self {
22
-
Self {
23
-
actor: Default::default(),
24
-
cursor: Default::default(),
25
-
limit: Some(50i64),
21
+
impl jacquard_common::IntoStatic for GetActorStarterPacks<'_> {
22
+
type Output = GetActorStarterPacks<'static>;
23
+
fn into_static(self) -> Self::Output {
24
+
GetActorStarterPacks {
25
+
actor: self.actor.into_static(),
26
+
cursor: self.cursor.into_static(),
27
+
limit: self.limit.into_static(),
26
28
}
27
29
}
28
30
}
···
38
40
pub starter_packs: Vec<crate::app_bsky::graph::StarterPackViewBasic<'a>>,
39
41
}
40
42
43
+
impl jacquard_common::IntoStatic for GetActorStarterPacksOutput<'_> {
44
+
type Output = GetActorStarterPacksOutput<'static>;
45
+
fn into_static(self) -> Self::Output {
46
+
GetActorStarterPacksOutput {
47
+
cursor: self.cursor.into_static(),
48
+
starter_packs: self.starter_packs.into_static(),
49
+
extra_data: self.extra_data.into_static(),
50
+
}
51
+
}
52
+
}
53
+
41
54
impl jacquard_common::types::xrpc::XrpcRequest for GetActorStarterPacks<'_> {
42
55
const NSID: &'static str = "app.bsky.graph.getActorStarterPacks";
43
56
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
44
57
const OUTPUT_ENCODING: &'static str = "application/json";
45
58
type Output<'de> = GetActorStarterPacksOutput<'de>;
46
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
59
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
47
60
}
+20
-7
crates/jacquard-api/src/app_bsky/graph/get_blocks.rs
+20
-7
crates/jacquard-api/src/app_bsky/graph/get_blocks.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetBlocks<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
12
#[serde(borrow)]
13
13
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
14
+
///(default: 50, min: 1, max: 100)
14
15
#[serde(skip_serializing_if = "std::option::Option::is_none")]
15
16
pub limit: std::option::Option<i64>,
16
17
}
17
18
18
-
impl Default for GetBlocks<'_> {
19
-
fn default() -> Self {
20
-
Self {
21
-
cursor: Default::default(),
22
-
limit: Some(50i64),
19
+
impl jacquard_common::IntoStatic for GetBlocks<'_> {
20
+
type Output = GetBlocks<'static>;
21
+
fn into_static(self) -> Self::Output {
22
+
GetBlocks {
23
+
cursor: self.cursor.into_static(),
24
+
limit: self.limit.into_static(),
23
25
}
24
26
}
25
27
}
···
35
37
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
36
38
}
37
39
40
+
impl jacquard_common::IntoStatic for GetBlocksOutput<'_> {
41
+
type Output = GetBlocksOutput<'static>;
42
+
fn into_static(self) -> Self::Output {
43
+
GetBlocksOutput {
44
+
blocks: self.blocks.into_static(),
45
+
cursor: self.cursor.into_static(),
46
+
extra_data: self.extra_data.into_static(),
47
+
}
48
+
}
49
+
}
50
+
38
51
impl jacquard_common::types::xrpc::XrpcRequest for GetBlocks<'_> {
39
52
const NSID: &'static str = "app.bsky.graph.getBlocks";
40
53
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
41
54
const OUTPUT_ENCODING: &'static str = "application/json";
42
55
type Output<'de> = GetBlocksOutput<'de>;
43
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
56
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
44
57
}
+22
-8
crates/jacquard-api/src/app_bsky/graph/get_followers.rs
+22
-8
crates/jacquard-api/src/app_bsky/graph/get_followers.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetFollowers<'a> {
11
11
#[serde(borrow)]
···
13
13
#[serde(skip_serializing_if = "std::option::Option::is_none")]
14
14
#[serde(borrow)]
15
15
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
16
+
///(default: 50, min: 1, max: 100)
16
17
#[serde(skip_serializing_if = "std::option::Option::is_none")]
17
18
pub limit: std::option::Option<i64>,
18
19
}
19
20
20
-
impl Default for GetFollowers<'_> {
21
-
fn default() -> Self {
22
-
Self {
23
-
actor: Default::default(),
24
-
cursor: Default::default(),
25
-
limit: Some(50i64),
21
+
impl jacquard_common::IntoStatic for GetFollowers<'_> {
22
+
type Output = GetFollowers<'static>;
23
+
fn into_static(self) -> Self::Output {
24
+
GetFollowers {
25
+
actor: self.actor.into_static(),
26
+
cursor: self.cursor.into_static(),
27
+
limit: self.limit.into_static(),
26
28
}
27
29
}
28
30
}
···
40
42
pub subject: crate::app_bsky::actor::ProfileView<'a>,
41
43
}
42
44
45
+
impl jacquard_common::IntoStatic for GetFollowersOutput<'_> {
46
+
type Output = GetFollowersOutput<'static>;
47
+
fn into_static(self) -> Self::Output {
48
+
GetFollowersOutput {
49
+
cursor: self.cursor.into_static(),
50
+
followers: self.followers.into_static(),
51
+
subject: self.subject.into_static(),
52
+
extra_data: self.extra_data.into_static(),
53
+
}
54
+
}
55
+
}
56
+
43
57
impl jacquard_common::types::xrpc::XrpcRequest for GetFollowers<'_> {
44
58
const NSID: &'static str = "app.bsky.graph.getFollowers";
45
59
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
46
60
const OUTPUT_ENCODING: &'static str = "application/json";
47
61
type Output<'de> = GetFollowersOutput<'de>;
48
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
62
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
49
63
}
+22
-8
crates/jacquard-api/src/app_bsky/graph/get_follows.rs
+22
-8
crates/jacquard-api/src/app_bsky/graph/get_follows.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetFollows<'a> {
11
11
#[serde(borrow)]
···
13
13
#[serde(skip_serializing_if = "std::option::Option::is_none")]
14
14
#[serde(borrow)]
15
15
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
16
+
///(default: 50, min: 1, max: 100)
16
17
#[serde(skip_serializing_if = "std::option::Option::is_none")]
17
18
pub limit: std::option::Option<i64>,
18
19
}
19
20
20
-
impl Default for GetFollows<'_> {
21
-
fn default() -> Self {
22
-
Self {
23
-
actor: Default::default(),
24
-
cursor: Default::default(),
25
-
limit: Some(50i64),
21
+
impl jacquard_common::IntoStatic for GetFollows<'_> {
22
+
type Output = GetFollows<'static>;
23
+
fn into_static(self) -> Self::Output {
24
+
GetFollows {
25
+
actor: self.actor.into_static(),
26
+
cursor: self.cursor.into_static(),
27
+
limit: self.limit.into_static(),
26
28
}
27
29
}
28
30
}
···
40
42
pub subject: crate::app_bsky::actor::ProfileView<'a>,
41
43
}
42
44
45
+
impl jacquard_common::IntoStatic for GetFollowsOutput<'_> {
46
+
type Output = GetFollowsOutput<'static>;
47
+
fn into_static(self) -> Self::Output {
48
+
GetFollowsOutput {
49
+
cursor: self.cursor.into_static(),
50
+
follows: self.follows.into_static(),
51
+
subject: self.subject.into_static(),
52
+
extra_data: self.extra_data.into_static(),
53
+
}
54
+
}
55
+
}
56
+
43
57
impl jacquard_common::types::xrpc::XrpcRequest for GetFollows<'_> {
44
58
const NSID: &'static str = "app.bsky.graph.getFollows";
45
59
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
46
60
const OUTPUT_ENCODING: &'static str = "application/json";
47
61
type Output<'de> = GetFollowsOutput<'de>;
48
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
62
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
49
63
}
+22
-8
crates/jacquard-api/src/app_bsky/graph/get_known_followers.rs
+22
-8
crates/jacquard-api/src/app_bsky/graph/get_known_followers.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetKnownFollowers<'a> {
11
11
#[serde(borrow)]
···
13
13
#[serde(skip_serializing_if = "std::option::Option::is_none")]
14
14
#[serde(borrow)]
15
15
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
16
+
///(default: 50, min: 1, max: 100)
16
17
#[serde(skip_serializing_if = "std::option::Option::is_none")]
17
18
pub limit: std::option::Option<i64>,
18
19
}
19
20
20
-
impl Default for GetKnownFollowers<'_> {
21
-
fn default() -> Self {
22
-
Self {
23
-
actor: Default::default(),
24
-
cursor: Default::default(),
25
-
limit: Some(50i64),
21
+
impl jacquard_common::IntoStatic for GetKnownFollowers<'_> {
22
+
type Output = GetKnownFollowers<'static>;
23
+
fn into_static(self) -> Self::Output {
24
+
GetKnownFollowers {
25
+
actor: self.actor.into_static(),
26
+
cursor: self.cursor.into_static(),
27
+
limit: self.limit.into_static(),
26
28
}
27
29
}
28
30
}
···
40
42
pub subject: crate::app_bsky::actor::ProfileView<'a>,
41
43
}
42
44
45
+
impl jacquard_common::IntoStatic for GetKnownFollowersOutput<'_> {
46
+
type Output = GetKnownFollowersOutput<'static>;
47
+
fn into_static(self) -> Self::Output {
48
+
GetKnownFollowersOutput {
49
+
cursor: self.cursor.into_static(),
50
+
followers: self.followers.into_static(),
51
+
subject: self.subject.into_static(),
52
+
extra_data: self.extra_data.into_static(),
53
+
}
54
+
}
55
+
}
56
+
43
57
impl jacquard_common::types::xrpc::XrpcRequest for GetKnownFollowers<'_> {
44
58
const NSID: &'static str = "app.bsky.graph.getKnownFollowers";
45
59
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
46
60
const OUTPUT_ENCODING: &'static str = "application/json";
47
61
type Output<'de> = GetKnownFollowersOutput<'de>;
48
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
62
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
49
63
}
+22
-8
crates/jacquard-api/src/app_bsky/graph/get_list.rs
+22
-8
crates/jacquard-api/src/app_bsky/graph/get_list.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetList<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
12
#[serde(borrow)]
13
13
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
14
+
///(default: 50, min: 1, max: 100)
14
15
#[serde(skip_serializing_if = "std::option::Option::is_none")]
15
16
pub limit: std::option::Option<i64>,
16
17
#[serde(borrow)]
17
18
pub list: jacquard_common::types::string::AtUri<'a>,
18
19
}
19
20
20
-
impl Default for GetList<'_> {
21
-
fn default() -> Self {
22
-
Self {
23
-
cursor: Default::default(),
24
-
limit: Some(50i64),
25
-
list: Default::default(),
21
+
impl jacquard_common::IntoStatic for GetList<'_> {
22
+
type Output = GetList<'static>;
23
+
fn into_static(self) -> Self::Output {
24
+
GetList {
25
+
cursor: self.cursor.into_static(),
26
+
limit: self.limit.into_static(),
27
+
list: self.list.into_static(),
26
28
}
27
29
}
28
30
}
···
40
42
pub list: crate::app_bsky::graph::ListView<'a>,
41
43
}
42
44
45
+
impl jacquard_common::IntoStatic for GetListOutput<'_> {
46
+
type Output = GetListOutput<'static>;
47
+
fn into_static(self) -> Self::Output {
48
+
GetListOutput {
49
+
cursor: self.cursor.into_static(),
50
+
items: self.items.into_static(),
51
+
list: self.list.into_static(),
52
+
extra_data: self.extra_data.into_static(),
53
+
}
54
+
}
55
+
}
56
+
43
57
impl jacquard_common::types::xrpc::XrpcRequest for GetList<'_> {
44
58
const NSID: &'static str = "app.bsky.graph.getList";
45
59
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
46
60
const OUTPUT_ENCODING: &'static str = "application/json";
47
61
type Output<'de> = GetListOutput<'de>;
48
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
62
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
49
63
}
+20
-7
crates/jacquard-api/src/app_bsky/graph/get_list_blocks.rs
+20
-7
crates/jacquard-api/src/app_bsky/graph/get_list_blocks.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetListBlocks<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
12
#[serde(borrow)]
13
13
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
14
+
///(default: 50, min: 1, max: 100)
14
15
#[serde(skip_serializing_if = "std::option::Option::is_none")]
15
16
pub limit: std::option::Option<i64>,
16
17
}
17
18
18
-
impl Default for GetListBlocks<'_> {
19
-
fn default() -> Self {
20
-
Self {
21
-
cursor: Default::default(),
22
-
limit: Some(50i64),
19
+
impl jacquard_common::IntoStatic for GetListBlocks<'_> {
20
+
type Output = GetListBlocks<'static>;
21
+
fn into_static(self) -> Self::Output {
22
+
GetListBlocks {
23
+
cursor: self.cursor.into_static(),
24
+
limit: self.limit.into_static(),
23
25
}
24
26
}
25
27
}
···
35
37
pub lists: Vec<crate::app_bsky::graph::ListView<'a>>,
36
38
}
37
39
40
+
impl jacquard_common::IntoStatic for GetListBlocksOutput<'_> {
41
+
type Output = GetListBlocksOutput<'static>;
42
+
fn into_static(self) -> Self::Output {
43
+
GetListBlocksOutput {
44
+
cursor: self.cursor.into_static(),
45
+
lists: self.lists.into_static(),
46
+
extra_data: self.extra_data.into_static(),
47
+
}
48
+
}
49
+
}
50
+
38
51
impl jacquard_common::types::xrpc::XrpcRequest for GetListBlocks<'_> {
39
52
const NSID: &'static str = "app.bsky.graph.getListBlocks";
40
53
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
41
54
const OUTPUT_ENCODING: &'static str = "application/json";
42
55
type Output<'de> = GetListBlocksOutput<'de>;
43
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
56
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
44
57
}
+20
-7
crates/jacquard-api/src/app_bsky/graph/get_list_mutes.rs
+20
-7
crates/jacquard-api/src/app_bsky/graph/get_list_mutes.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetListMutes<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
12
#[serde(borrow)]
13
13
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
14
+
///(default: 50, min: 1, max: 100)
14
15
#[serde(skip_serializing_if = "std::option::Option::is_none")]
15
16
pub limit: std::option::Option<i64>,
16
17
}
17
18
18
-
impl Default for GetListMutes<'_> {
19
-
fn default() -> Self {
20
-
Self {
21
-
cursor: Default::default(),
22
-
limit: Some(50i64),
19
+
impl jacquard_common::IntoStatic for GetListMutes<'_> {
20
+
type Output = GetListMutes<'static>;
21
+
fn into_static(self) -> Self::Output {
22
+
GetListMutes {
23
+
cursor: self.cursor.into_static(),
24
+
limit: self.limit.into_static(),
23
25
}
24
26
}
25
27
}
···
35
37
pub lists: Vec<crate::app_bsky::graph::ListView<'a>>,
36
38
}
37
39
40
+
impl jacquard_common::IntoStatic for GetListMutesOutput<'_> {
41
+
type Output = GetListMutesOutput<'static>;
42
+
fn into_static(self) -> Self::Output {
43
+
GetListMutesOutput {
44
+
cursor: self.cursor.into_static(),
45
+
lists: self.lists.into_static(),
46
+
extra_data: self.extra_data.into_static(),
47
+
}
48
+
}
49
+
}
50
+
38
51
impl jacquard_common::types::xrpc::XrpcRequest for GetListMutes<'_> {
39
52
const NSID: &'static str = "app.bsky.graph.getListMutes";
40
53
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
41
54
const OUTPUT_ENCODING: &'static str = "application/json";
42
55
type Output<'de> = GetListMutesOutput<'de>;
43
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
56
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
44
57
}
+22
-9
crates/jacquard-api/src/app_bsky/graph/get_lists.rs
+22
-9
crates/jacquard-api/src/app_bsky/graph/get_lists.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetLists<'a> {
11
11
#[serde(borrow)]
···
13
13
#[serde(skip_serializing_if = "std::option::Option::is_none")]
14
14
#[serde(borrow)]
15
15
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
16
+
///(default: 50, min: 1, max: 100)
16
17
#[serde(skip_serializing_if = "std::option::Option::is_none")]
17
18
pub limit: std::option::Option<i64>,
18
19
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
20
21
pub purposes: std::option::Option<Vec<jacquard_common::CowStr<'a>>>,
21
22
}
22
23
23
-
impl Default for GetLists<'_> {
24
-
fn default() -> Self {
25
-
Self {
26
-
actor: Default::default(),
27
-
cursor: Default::default(),
28
-
limit: Some(50i64),
29
-
purposes: Default::default(),
24
+
impl jacquard_common::IntoStatic for GetLists<'_> {
25
+
type Output = GetLists<'static>;
26
+
fn into_static(self) -> Self::Output {
27
+
GetLists {
28
+
actor: self.actor.into_static(),
29
+
cursor: self.cursor.into_static(),
30
+
limit: self.limit.into_static(),
31
+
purposes: self.purposes.into_static(),
30
32
}
31
33
}
32
34
}
···
42
44
pub lists: Vec<crate::app_bsky::graph::ListView<'a>>,
43
45
}
44
46
47
+
impl jacquard_common::IntoStatic for GetListsOutput<'_> {
48
+
type Output = GetListsOutput<'static>;
49
+
fn into_static(self) -> Self::Output {
50
+
GetListsOutput {
51
+
cursor: self.cursor.into_static(),
52
+
lists: self.lists.into_static(),
53
+
extra_data: self.extra_data.into_static(),
54
+
}
55
+
}
56
+
}
57
+
45
58
impl jacquard_common::types::xrpc::XrpcRequest for GetLists<'_> {
46
59
const NSID: &'static str = "app.bsky.graph.getLists";
47
60
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
48
61
const OUTPUT_ENCODING: &'static str = "application/json";
49
62
type Output<'de> = GetListsOutput<'de>;
50
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
63
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
51
64
}
+33
-9
crates/jacquard-api/src/app_bsky/graph/get_lists_with_membership.rs
+33
-9
crates/jacquard-api/src/app_bsky/graph/get_lists_with_membership.rs
···
17
17
pub list_item: std::option::Option<crate::app_bsky::graph::ListItemView<'a>>,
18
18
}
19
19
20
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
20
+
impl jacquard_common::IntoStatic for ListWithMembership<'_> {
21
+
type Output = ListWithMembership<'static>;
22
+
fn into_static(self) -> Self::Output {
23
+
ListWithMembership {
24
+
list: self.list.into_static(),
25
+
list_item: self.list_item.into_static(),
26
+
extra_data: self.extra_data.into_static(),
27
+
}
28
+
}
29
+
}
30
+
31
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
21
32
#[serde(rename_all = "camelCase")]
22
33
pub struct GetListsWithMembership<'a> {
23
34
#[serde(borrow)]
···
25
36
#[serde(skip_serializing_if = "std::option::Option::is_none")]
26
37
#[serde(borrow)]
27
38
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
39
+
///(default: 50, min: 1, max: 100)
28
40
#[serde(skip_serializing_if = "std::option::Option::is_none")]
29
41
pub limit: std::option::Option<i64>,
30
42
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
32
44
pub purposes: std::option::Option<Vec<jacquard_common::CowStr<'a>>>,
33
45
}
34
46
35
-
impl Default for GetListsWithMembership<'_> {
36
-
fn default() -> Self {
37
-
Self {
38
-
actor: Default::default(),
39
-
cursor: Default::default(),
40
-
limit: Some(50i64),
41
-
purposes: Default::default(),
47
+
impl jacquard_common::IntoStatic for GetListsWithMembership<'_> {
48
+
type Output = GetListsWithMembership<'static>;
49
+
fn into_static(self) -> Self::Output {
50
+
GetListsWithMembership {
51
+
actor: self.actor.into_static(),
52
+
cursor: self.cursor.into_static(),
53
+
limit: self.limit.into_static(),
54
+
purposes: self.purposes.into_static(),
42
55
}
43
56
}
44
57
}
···
54
67
pub lists_with_membership: Vec<jacquard_common::types::value::Data<'a>>,
55
68
}
56
69
70
+
impl jacquard_common::IntoStatic for GetListsWithMembershipOutput<'_> {
71
+
type Output = GetListsWithMembershipOutput<'static>;
72
+
fn into_static(self) -> Self::Output {
73
+
GetListsWithMembershipOutput {
74
+
cursor: self.cursor.into_static(),
75
+
lists_with_membership: self.lists_with_membership.into_static(),
76
+
extra_data: self.extra_data.into_static(),
77
+
}
78
+
}
79
+
}
80
+
57
81
impl jacquard_common::types::xrpc::XrpcRequest for GetListsWithMembership<'_> {
58
82
const NSID: &'static str = "app.bsky.graph.getListsWithMembership";
59
83
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
60
84
const OUTPUT_ENCODING: &'static str = "application/json";
61
85
type Output<'de> = GetListsWithMembershipOutput<'de>;
62
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
86
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
63
87
}
+20
-7
crates/jacquard-api/src/app_bsky/graph/get_mutes.rs
+20
-7
crates/jacquard-api/src/app_bsky/graph/get_mutes.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetMutes<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
12
#[serde(borrow)]
13
13
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
14
+
///(default: 50, min: 1, max: 100)
14
15
#[serde(skip_serializing_if = "std::option::Option::is_none")]
15
16
pub limit: std::option::Option<i64>,
16
17
}
17
18
18
-
impl Default for GetMutes<'_> {
19
-
fn default() -> Self {
20
-
Self {
21
-
cursor: Default::default(),
22
-
limit: Some(50i64),
19
+
impl jacquard_common::IntoStatic for GetMutes<'_> {
20
+
type Output = GetMutes<'static>;
21
+
fn into_static(self) -> Self::Output {
22
+
GetMutes {
23
+
cursor: self.cursor.into_static(),
24
+
limit: self.limit.into_static(),
23
25
}
24
26
}
25
27
}
···
35
37
pub mutes: Vec<crate::app_bsky::actor::ProfileView<'a>>,
36
38
}
37
39
40
+
impl jacquard_common::IntoStatic for GetMutesOutput<'_> {
41
+
type Output = GetMutesOutput<'static>;
42
+
fn into_static(self) -> Self::Output {
43
+
GetMutesOutput {
44
+
cursor: self.cursor.into_static(),
45
+
mutes: self.mutes.into_static(),
46
+
extra_data: self.extra_data.into_static(),
47
+
}
48
+
}
49
+
}
50
+
38
51
impl jacquard_common::types::xrpc::XrpcRequest for GetMutes<'_> {
39
52
const NSID: &'static str = "app.bsky.graph.getMutes";
40
53
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
41
54
const OUTPUT_ENCODING: &'static str = "application/json";
42
55
type Output<'de> = GetMutesOutput<'de>;
43
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
56
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
44
57
}
+35
crates/jacquard-api/src/app_bsky/graph/get_relationships.rs
+35
crates/jacquard-api/src/app_bsky/graph/get_relationships.rs
···
17
17
>,
18
18
}
19
19
20
+
impl jacquard_common::IntoStatic for GetRelationships<'_> {
21
+
type Output = GetRelationships<'static>;
22
+
fn into_static(self) -> Self::Output {
23
+
GetRelationships {
24
+
actor: self.actor.into_static(),
25
+
others: self.others.into_static(),
26
+
}
27
+
}
28
+
}
29
+
20
30
#[jacquard_derive::lexicon]
21
31
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
22
32
#[serde(rename_all = "camelCase")]
···
28
38
pub relationships: Vec<jacquard_common::types::value::Data<'a>>,
29
39
}
30
40
41
+
impl jacquard_common::IntoStatic for GetRelationshipsOutput<'_> {
42
+
type Output = GetRelationshipsOutput<'static>;
43
+
fn into_static(self) -> Self::Output {
44
+
GetRelationshipsOutput {
45
+
actor: self.actor.into_static(),
46
+
relationships: self.relationships.into_static(),
47
+
extra_data: self.extra_data.into_static(),
48
+
}
49
+
}
50
+
}
51
+
31
52
#[jacquard_derive::open_union]
32
53
#[derive(
33
54
serde::Serialize,
···
58
79
Ok(())
59
80
}
60
81
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
82
+
}
83
+
}
84
+
}
85
+
86
+
impl jacquard_common::IntoStatic for GetRelationshipsError<'_> {
87
+
type Output = GetRelationshipsError<'static>;
88
+
fn into_static(self) -> Self::Output {
89
+
match self {
90
+
GetRelationshipsError::ActorNotFound(v) => {
91
+
GetRelationshipsError::ActorNotFound(v.into_static())
92
+
}
93
+
GetRelationshipsError::Unknown(v) => {
94
+
GetRelationshipsError::Unknown(v.into_static())
95
+
}
61
96
}
62
97
}
63
98
}
+20
-1
crates/jacquard-api/src/app_bsky/graph/get_starter_pack.rs
+20
-1
crates/jacquard-api/src/app_bsky/graph/get_starter_pack.rs
···
12
12
pub starter_pack: jacquard_common::types::string::AtUri<'a>,
13
13
}
14
14
15
+
impl jacquard_common::IntoStatic for GetStarterPack<'_> {
16
+
type Output = GetStarterPack<'static>;
17
+
fn into_static(self) -> Self::Output {
18
+
GetStarterPack {
19
+
starter_pack: self.starter_pack.into_static(),
20
+
}
21
+
}
22
+
}
23
+
15
24
#[jacquard_derive::lexicon]
16
25
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
26
#[serde(rename_all = "camelCase")]
···
20
29
pub starter_pack: crate::app_bsky::graph::StarterPackView<'a>,
21
30
}
22
31
32
+
impl jacquard_common::IntoStatic for GetStarterPackOutput<'_> {
33
+
type Output = GetStarterPackOutput<'static>;
34
+
fn into_static(self) -> Self::Output {
35
+
GetStarterPackOutput {
36
+
starter_pack: self.starter_pack.into_static(),
37
+
extra_data: self.extra_data.into_static(),
38
+
}
39
+
}
40
+
}
41
+
23
42
impl jacquard_common::types::xrpc::XrpcRequest for GetStarterPack<'_> {
24
43
const NSID: &'static str = "app.bsky.graph.getStarterPack";
25
44
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
26
45
const OUTPUT_ENCODING: &'static str = "application/json";
27
46
type Output<'de> = GetStarterPackOutput<'de>;
28
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
47
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
29
48
}
+20
-1
crates/jacquard-api/src/app_bsky/graph/get_starter_packs.rs
+20
-1
crates/jacquard-api/src/app_bsky/graph/get_starter_packs.rs
···
12
12
pub uris: Vec<jacquard_common::types::string::AtUri<'a>>,
13
13
}
14
14
15
+
impl jacquard_common::IntoStatic for GetStarterPacks<'_> {
16
+
type Output = GetStarterPacks<'static>;
17
+
fn into_static(self) -> Self::Output {
18
+
GetStarterPacks {
19
+
uris: self.uris.into_static(),
20
+
}
21
+
}
22
+
}
23
+
15
24
#[jacquard_derive::lexicon]
16
25
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
26
#[serde(rename_all = "camelCase")]
···
20
29
pub starter_packs: Vec<crate::app_bsky::graph::StarterPackViewBasic<'a>>,
21
30
}
22
31
32
+
impl jacquard_common::IntoStatic for GetStarterPacksOutput<'_> {
33
+
type Output = GetStarterPacksOutput<'static>;
34
+
fn into_static(self) -> Self::Output {
35
+
GetStarterPacksOutput {
36
+
starter_packs: self.starter_packs.into_static(),
37
+
extra_data: self.extra_data.into_static(),
38
+
}
39
+
}
40
+
}
41
+
23
42
impl jacquard_common::types::xrpc::XrpcRequest for GetStarterPacks<'_> {
24
43
const NSID: &'static str = "app.bsky.graph.getStarterPacks";
25
44
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
26
45
const OUTPUT_ENCODING: &'static str = "application/json";
27
46
type Output<'de> = GetStarterPacksOutput<'de>;
28
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
47
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
29
48
}
+34
-8
crates/jacquard-api/src/app_bsky/graph/get_starter_packs_with_membership.rs
+34
-8
crates/jacquard-api/src/app_bsky/graph/get_starter_packs_with_membership.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetStarterPacksWithMembership<'a> {
11
11
#[serde(borrow)]
···
13
13
#[serde(skip_serializing_if = "std::option::Option::is_none")]
14
14
#[serde(borrow)]
15
15
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
16
+
///(default: 50, min: 1, max: 100)
16
17
#[serde(skip_serializing_if = "std::option::Option::is_none")]
17
18
pub limit: std::option::Option<i64>,
18
19
}
19
20
20
-
impl Default for GetStarterPacksWithMembership<'_> {
21
-
fn default() -> Self {
22
-
Self {
23
-
actor: Default::default(),
24
-
cursor: Default::default(),
25
-
limit: Some(50i64),
21
+
impl jacquard_common::IntoStatic for GetStarterPacksWithMembership<'_> {
22
+
type Output = GetStarterPacksWithMembership<'static>;
23
+
fn into_static(self) -> Self::Output {
24
+
GetStarterPacksWithMembership {
25
+
actor: self.actor.into_static(),
26
+
cursor: self.cursor.into_static(),
27
+
limit: self.limit.into_static(),
26
28
}
27
29
}
28
30
}
···
38
40
pub starter_packs_with_membership: Vec<jacquard_common::types::value::Data<'a>>,
39
41
}
40
42
43
+
impl jacquard_common::IntoStatic for GetStarterPacksWithMembershipOutput<'_> {
44
+
type Output = GetStarterPacksWithMembershipOutput<'static>;
45
+
fn into_static(self) -> Self::Output {
46
+
GetStarterPacksWithMembershipOutput {
47
+
cursor: self.cursor.into_static(),
48
+
starter_packs_with_membership: self
49
+
.starter_packs_with_membership
50
+
.into_static(),
51
+
extra_data: self.extra_data.into_static(),
52
+
}
53
+
}
54
+
}
55
+
41
56
impl jacquard_common::types::xrpc::XrpcRequest for GetStarterPacksWithMembership<'_> {
42
57
const NSID: &'static str = "app.bsky.graph.getStarterPacksWithMembership";
43
58
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
44
59
const OUTPUT_ENCODING: &'static str = "application/json";
45
60
type Output<'de> = GetStarterPacksWithMembershipOutput<'de>;
46
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
61
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
47
62
}
48
63
49
64
///A starter pack and an optional list item indicating membership of a target user to that starter pack.
···
56
71
pub list_item: std::option::Option<crate::app_bsky::graph::ListItemView<'a>>,
57
72
#[serde(borrow)]
58
73
pub starter_pack: crate::app_bsky::graph::StarterPackView<'a>,
74
+
}
75
+
76
+
impl jacquard_common::IntoStatic for StarterPackWithMembership<'_> {
77
+
type Output = StarterPackWithMembership<'static>;
78
+
fn into_static(self) -> Self::Output {
79
+
StarterPackWithMembership {
80
+
list_item: self.list_item.into_static(),
81
+
starter_pack: self.starter_pack.into_static(),
82
+
extra_data: self.extra_data.into_static(),
83
+
}
84
+
}
59
85
}
+22
-1
crates/jacquard-api/src/app_bsky/graph/get_suggested_follows_by_actor.rs
+22
-1
crates/jacquard-api/src/app_bsky/graph/get_suggested_follows_by_actor.rs
···
12
12
pub actor: jacquard_common::types::ident::AtIdentifier<'a>,
13
13
}
14
14
15
+
impl jacquard_common::IntoStatic for GetSuggestedFollowsByActor<'_> {
16
+
type Output = GetSuggestedFollowsByActor<'static>;
17
+
fn into_static(self) -> Self::Output {
18
+
GetSuggestedFollowsByActor {
19
+
actor: self.actor.into_static(),
20
+
}
21
+
}
22
+
}
23
+
15
24
#[jacquard_derive::lexicon]
16
25
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
26
#[serde(rename_all = "camelCase")]
···
26
35
pub suggestions: Vec<crate::app_bsky::actor::ProfileView<'a>>,
27
36
}
28
37
38
+
impl jacquard_common::IntoStatic for GetSuggestedFollowsByActorOutput<'_> {
39
+
type Output = GetSuggestedFollowsByActorOutput<'static>;
40
+
fn into_static(self) -> Self::Output {
41
+
GetSuggestedFollowsByActorOutput {
42
+
is_fallback: self.is_fallback.into_static(),
43
+
rec_id: self.rec_id.into_static(),
44
+
suggestions: self.suggestions.into_static(),
45
+
extra_data: self.extra_data.into_static(),
46
+
}
47
+
}
48
+
}
49
+
29
50
impl jacquard_common::types::xrpc::XrpcRequest for GetSuggestedFollowsByActor<'_> {
30
51
const NSID: &'static str = "app.bsky.graph.getSuggestedFollowsByActor";
31
52
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
32
53
const OUTPUT_ENCODING: &'static str = "application/json";
33
54
type Output<'de> = GetSuggestedFollowsByActorOutput<'de>;
34
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
55
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
35
56
}
+28
crates/jacquard-api/src/app_bsky/graph/list.rs
+28
crates/jacquard-api/src/app_bsky/graph/list.rs
···
42
42
DefsSelfLabels(Box<crate::com_atproto::label::SelfLabels<'a>>),
43
43
}
44
44
45
+
impl jacquard_common::IntoStatic for ListRecordLabels<'_> {
46
+
type Output = ListRecordLabels<'static>;
47
+
fn into_static(self) -> Self::Output {
48
+
match self {
49
+
ListRecordLabels::DefsSelfLabels(v) => {
50
+
ListRecordLabels::DefsSelfLabels(v.into_static())
51
+
}
52
+
ListRecordLabels::Unknown(v) => ListRecordLabels::Unknown(v.into_static()),
53
+
}
54
+
}
55
+
}
56
+
45
57
impl jacquard_common::types::collection::Collection for List<'_> {
46
58
const NSID: &'static str = "app.bsky.graph.list";
59
+
}
60
+
61
+
impl jacquard_common::IntoStatic for List<'_> {
62
+
type Output = List<'static>;
63
+
fn into_static(self) -> Self::Output {
64
+
List {
65
+
avatar: self.avatar.into_static(),
66
+
created_at: self.created_at.into_static(),
67
+
description: self.description.into_static(),
68
+
description_facets: self.description_facets.into_static(),
69
+
labels: self.labels.into_static(),
70
+
name: self.name.into_static(),
71
+
purpose: self.purpose.into_static(),
72
+
extra_data: self.extra_data.into_static(),
73
+
}
74
+
}
47
75
}
+11
crates/jacquard-api/src/app_bsky/graph/listblock.rs
+11
crates/jacquard-api/src/app_bsky/graph/listblock.rs
···
18
18
19
19
impl jacquard_common::types::collection::Collection for Listblock<'_> {
20
20
const NSID: &'static str = "app.bsky.graph.listblock";
21
+
}
22
+
23
+
impl jacquard_common::IntoStatic for Listblock<'_> {
24
+
type Output = Listblock<'static>;
25
+
fn into_static(self) -> Self::Output {
26
+
Listblock {
27
+
created_at: self.created_at.into_static(),
28
+
subject: self.subject.into_static(),
29
+
extra_data: self.extra_data.into_static(),
30
+
}
31
+
}
21
32
}
+12
crates/jacquard-api/src/app_bsky/graph/listitem.rs
+12
crates/jacquard-api/src/app_bsky/graph/listitem.rs
···
21
21
22
22
impl jacquard_common::types::collection::Collection for Listitem<'_> {
23
23
const NSID: &'static str = "app.bsky.graph.listitem";
24
+
}
25
+
26
+
impl jacquard_common::IntoStatic for Listitem<'_> {
27
+
type Output = Listitem<'static>;
28
+
fn into_static(self) -> Self::Output {
29
+
Listitem {
30
+
created_at: self.created_at.into_static(),
31
+
list: self.list.into_static(),
32
+
subject: self.subject.into_static(),
33
+
extra_data: self.extra_data.into_static(),
34
+
}
35
+
}
24
36
}
+11
-1
crates/jacquard-api/src/app_bsky/graph/mute_actor.rs
+11
-1
crates/jacquard-api/src/app_bsky/graph/mute_actor.rs
···
13
13
pub actor: jacquard_common::types::ident::AtIdentifier<'a>,
14
14
}
15
15
16
+
impl jacquard_common::IntoStatic for MuteActor<'_> {
17
+
type Output = MuteActor<'static>;
18
+
fn into_static(self) -> Self::Output {
19
+
MuteActor {
20
+
actor: self.actor.into_static(),
21
+
extra_data: self.extra_data.into_static(),
22
+
}
23
+
}
24
+
}
25
+
16
26
impl jacquard_common::types::xrpc::XrpcRequest for MuteActor<'_> {
17
27
const NSID: &'static str = "app.bsky.graph.muteActor";
18
28
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
20
30
);
21
31
const OUTPUT_ENCODING: &'static str = "application/json";
22
32
type Output<'de> = ();
23
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
33
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
24
34
}
+11
-1
crates/jacquard-api/src/app_bsky/graph/mute_actor_list.rs
+11
-1
crates/jacquard-api/src/app_bsky/graph/mute_actor_list.rs
···
13
13
pub list: jacquard_common::types::string::AtUri<'a>,
14
14
}
15
15
16
+
impl jacquard_common::IntoStatic for MuteActorList<'_> {
17
+
type Output = MuteActorList<'static>;
18
+
fn into_static(self) -> Self::Output {
19
+
MuteActorList {
20
+
list: self.list.into_static(),
21
+
extra_data: self.extra_data.into_static(),
22
+
}
23
+
}
24
+
}
25
+
16
26
impl jacquard_common::types::xrpc::XrpcRequest for MuteActorList<'_> {
17
27
const NSID: &'static str = "app.bsky.graph.muteActorList";
18
28
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
20
30
);
21
31
const OUTPUT_ENCODING: &'static str = "application/json";
22
32
type Output<'de> = ();
23
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
33
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
24
34
}
+11
-1
crates/jacquard-api/src/app_bsky/graph/mute_thread.rs
+11
-1
crates/jacquard-api/src/app_bsky/graph/mute_thread.rs
···
13
13
pub root: jacquard_common::types::string::AtUri<'a>,
14
14
}
15
15
16
+
impl jacquard_common::IntoStatic for MuteThread<'_> {
17
+
type Output = MuteThread<'static>;
18
+
fn into_static(self) -> Self::Output {
19
+
MuteThread {
20
+
root: self.root.into_static(),
21
+
extra_data: self.extra_data.into_static(),
22
+
}
23
+
}
24
+
}
25
+
16
26
impl jacquard_common::types::xrpc::XrpcRequest for MuteThread<'_> {
17
27
const NSID: &'static str = "app.bsky.graph.muteThread";
18
28
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
20
30
);
21
31
const OUTPUT_ENCODING: &'static str = "application/json";
22
32
type Output<'de> = ();
23
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
33
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
24
34
}
+21
-8
crates/jacquard-api/src/app_bsky/graph/search_starter_packs.rs
+21
-8
crates/jacquard-api/src/app_bsky/graph/search_starter_packs.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct SearchStarterPacks<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
12
#[serde(borrow)]
13
13
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
14
+
///(default: 25, min: 1, max: 100)
14
15
#[serde(skip_serializing_if = "std::option::Option::is_none")]
15
16
pub limit: std::option::Option<i64>,
16
17
#[serde(borrow)]
17
18
pub q: jacquard_common::CowStr<'a>,
18
19
}
19
20
20
-
impl Default for SearchStarterPacks<'_> {
21
-
fn default() -> Self {
22
-
Self {
23
-
cursor: Default::default(),
24
-
limit: Some(25i64),
25
-
q: Default::default(),
21
+
impl jacquard_common::IntoStatic for SearchStarterPacks<'_> {
22
+
type Output = SearchStarterPacks<'static>;
23
+
fn into_static(self) -> Self::Output {
24
+
SearchStarterPacks {
25
+
cursor: self.cursor.into_static(),
26
+
limit: self.limit.into_static(),
27
+
q: self.q.into_static(),
26
28
}
27
29
}
28
30
}
···
38
40
pub starter_packs: Vec<crate::app_bsky::graph::StarterPackViewBasic<'a>>,
39
41
}
40
42
43
+
impl jacquard_common::IntoStatic for SearchStarterPacksOutput<'_> {
44
+
type Output = SearchStarterPacksOutput<'static>;
45
+
fn into_static(self) -> Self::Output {
46
+
SearchStarterPacksOutput {
47
+
cursor: self.cursor.into_static(),
48
+
starter_packs: self.starter_packs.into_static(),
49
+
extra_data: self.extra_data.into_static(),
50
+
}
51
+
}
52
+
}
53
+
41
54
impl jacquard_common::types::xrpc::XrpcRequest for SearchStarterPacks<'_> {
42
55
const NSID: &'static str = "app.bsky.graph.searchStarterPacks";
43
56
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
44
57
const OUTPUT_ENCODING: &'static str = "application/json";
45
58
type Output<'de> = SearchStarterPacksOutput<'de>;
46
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
59
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
47
60
}
+25
crates/jacquard-api/src/app_bsky/graph/starterpack.rs
+25
crates/jacquard-api/src/app_bsky/graph/starterpack.rs
···
13
13
pub uri: jacquard_common::types::string::AtUri<'a>,
14
14
}
15
15
16
+
impl jacquard_common::IntoStatic for FeedItem<'_> {
17
+
type Output = FeedItem<'static>;
18
+
fn into_static(self) -> Self::Output {
19
+
FeedItem {
20
+
uri: self.uri.into_static(),
21
+
extra_data: self.extra_data.into_static(),
22
+
}
23
+
}
24
+
}
25
+
16
26
///Record defining a starter pack of actors and feeds for new users.
17
27
#[jacquard_derive::lexicon]
18
28
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
42
52
43
53
impl jacquard_common::types::collection::Collection for Starterpack<'_> {
44
54
const NSID: &'static str = "app.bsky.graph.starterpack";
55
+
}
56
+
57
+
impl jacquard_common::IntoStatic for Starterpack<'_> {
58
+
type Output = Starterpack<'static>;
59
+
fn into_static(self) -> Self::Output {
60
+
Starterpack {
61
+
created_at: self.created_at.into_static(),
62
+
description: self.description.into_static(),
63
+
description_facets: self.description_facets.into_static(),
64
+
feeds: self.feeds.into_static(),
65
+
list: self.list.into_static(),
66
+
name: self.name.into_static(),
67
+
extra_data: self.extra_data.into_static(),
68
+
}
69
+
}
45
70
}
+11
-1
crates/jacquard-api/src/app_bsky/graph/unmute_actor.rs
+11
-1
crates/jacquard-api/src/app_bsky/graph/unmute_actor.rs
···
13
13
pub actor: jacquard_common::types::ident::AtIdentifier<'a>,
14
14
}
15
15
16
+
impl jacquard_common::IntoStatic for UnmuteActor<'_> {
17
+
type Output = UnmuteActor<'static>;
18
+
fn into_static(self) -> Self::Output {
19
+
UnmuteActor {
20
+
actor: self.actor.into_static(),
21
+
extra_data: self.extra_data.into_static(),
22
+
}
23
+
}
24
+
}
25
+
16
26
impl jacquard_common::types::xrpc::XrpcRequest for UnmuteActor<'_> {
17
27
const NSID: &'static str = "app.bsky.graph.unmuteActor";
18
28
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
20
30
);
21
31
const OUTPUT_ENCODING: &'static str = "application/json";
22
32
type Output<'de> = ();
23
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
33
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
24
34
}
+11
-1
crates/jacquard-api/src/app_bsky/graph/unmute_actor_list.rs
+11
-1
crates/jacquard-api/src/app_bsky/graph/unmute_actor_list.rs
···
13
13
pub list: jacquard_common::types::string::AtUri<'a>,
14
14
}
15
15
16
+
impl jacquard_common::IntoStatic for UnmuteActorList<'_> {
17
+
type Output = UnmuteActorList<'static>;
18
+
fn into_static(self) -> Self::Output {
19
+
UnmuteActorList {
20
+
list: self.list.into_static(),
21
+
extra_data: self.extra_data.into_static(),
22
+
}
23
+
}
24
+
}
25
+
16
26
impl jacquard_common::types::xrpc::XrpcRequest for UnmuteActorList<'_> {
17
27
const NSID: &'static str = "app.bsky.graph.unmuteActorList";
18
28
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
20
30
);
21
31
const OUTPUT_ENCODING: &'static str = "application/json";
22
32
type Output<'de> = ();
23
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
33
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
24
34
}
+11
-1
crates/jacquard-api/src/app_bsky/graph/unmute_thread.rs
+11
-1
crates/jacquard-api/src/app_bsky/graph/unmute_thread.rs
···
13
13
pub root: jacquard_common::types::string::AtUri<'a>,
14
14
}
15
15
16
+
impl jacquard_common::IntoStatic for UnmuteThread<'_> {
17
+
type Output = UnmuteThread<'static>;
18
+
fn into_static(self) -> Self::Output {
19
+
UnmuteThread {
20
+
root: self.root.into_static(),
21
+
extra_data: self.extra_data.into_static(),
22
+
}
23
+
}
24
+
}
25
+
16
26
impl jacquard_common::types::xrpc::XrpcRequest for UnmuteThread<'_> {
17
27
const NSID: &'static str = "app.bsky.graph.unmuteThread";
18
28
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
20
30
);
21
31
const OUTPUT_ENCODING: &'static str = "application/json";
22
32
type Output<'de> = ();
23
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
33
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
24
34
}
+13
crates/jacquard-api/src/app_bsky/graph/verification.rs
+13
crates/jacquard-api/src/app_bsky/graph/verification.rs
···
25
25
26
26
impl jacquard_common::types::collection::Collection for Verification<'_> {
27
27
const NSID: &'static str = "app.bsky.graph.verification";
28
+
}
29
+
30
+
impl jacquard_common::IntoStatic for Verification<'_> {
31
+
type Output = Verification<'static>;
32
+
fn into_static(self) -> Self::Output {
33
+
Verification {
34
+
created_at: self.created_at.into_static(),
35
+
display_name: self.display_name.into_static(),
36
+
handle: self.handle.into_static(),
37
+
subject: self.subject.into_static(),
38
+
extra_data: self.extra_data.into_static(),
39
+
}
40
+
}
28
41
}
+57
crates/jacquard-api/src/app_bsky/labeler.rs
+57
crates/jacquard-api/src/app_bsky/labeler.rs
···
23
23
pub label_values: Vec<crate::com_atproto::label::LabelValue<'a>>,
24
24
}
25
25
26
+
impl jacquard_common::IntoStatic for LabelerPolicies<'_> {
27
+
type Output = LabelerPolicies<'static>;
28
+
fn into_static(self) -> Self::Output {
29
+
LabelerPolicies {
30
+
label_value_definitions: self.label_value_definitions.into_static(),
31
+
label_values: self.label_values.into_static(),
32
+
extra_data: self.extra_data.into_static(),
33
+
}
34
+
}
35
+
}
36
+
26
37
#[jacquard_derive::lexicon]
27
38
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
28
39
#[serde(rename_all = "camelCase")]
···
44
55
pub viewer: std::option::Option<crate::app_bsky::labeler::LabelerViewerState<'a>>,
45
56
}
46
57
58
+
impl jacquard_common::IntoStatic for LabelerView<'_> {
59
+
type Output = LabelerView<'static>;
60
+
fn into_static(self) -> Self::Output {
61
+
LabelerView {
62
+
cid: self.cid.into_static(),
63
+
creator: self.creator.into_static(),
64
+
indexed_at: self.indexed_at.into_static(),
65
+
labels: self.labels.into_static(),
66
+
like_count: self.like_count.into_static(),
67
+
uri: self.uri.into_static(),
68
+
viewer: self.viewer.into_static(),
69
+
extra_data: self.extra_data.into_static(),
70
+
}
71
+
}
72
+
}
73
+
47
74
#[jacquard_derive::lexicon]
48
75
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
49
76
#[serde(rename_all = "camelCase")]
···
85
112
pub viewer: std::option::Option<crate::app_bsky::labeler::LabelerViewerState<'a>>,
86
113
}
87
114
115
+
impl jacquard_common::IntoStatic for LabelerViewDetailed<'_> {
116
+
type Output = LabelerViewDetailed<'static>;
117
+
fn into_static(self) -> Self::Output {
118
+
LabelerViewDetailed {
119
+
cid: self.cid.into_static(),
120
+
creator: self.creator.into_static(),
121
+
indexed_at: self.indexed_at.into_static(),
122
+
labels: self.labels.into_static(),
123
+
like_count: self.like_count.into_static(),
124
+
policies: self.policies.into_static(),
125
+
reason_types: self.reason_types.into_static(),
126
+
subject_collections: self.subject_collections.into_static(),
127
+
subject_types: self.subject_types.into_static(),
128
+
uri: self.uri.into_static(),
129
+
viewer: self.viewer.into_static(),
130
+
extra_data: self.extra_data.into_static(),
131
+
}
132
+
}
133
+
}
134
+
88
135
#[jacquard_derive::lexicon]
89
136
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
90
137
#[serde(rename_all = "camelCase")]
···
92
139
#[serde(skip_serializing_if = "std::option::Option::is_none")]
93
140
#[serde(borrow)]
94
141
pub like: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
142
+
}
143
+
144
+
impl jacquard_common::IntoStatic for LabelerViewerState<'_> {
145
+
type Output = LabelerViewerState<'static>;
146
+
fn into_static(self) -> Self::Output {
147
+
LabelerViewerState {
148
+
like: self.like.into_static(),
149
+
extra_data: self.extra_data.into_static(),
150
+
}
151
+
}
95
152
}
+19
-7
crates/jacquard-api/src/app_bsky/labeler/get_services.rs
+19
-7
crates/jacquard-api/src/app_bsky/labeler/get_services.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetServices<'a> {
11
+
///(default: false)
11
12
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
13
pub detailed: std::option::Option<bool>,
13
14
#[serde(borrow)]
14
15
pub dids: Vec<jacquard_common::types::string::Did<'a>>,
15
16
}
16
17
17
-
impl Default for GetServices<'_> {
18
-
fn default() -> Self {
19
-
Self {
20
-
detailed: Some(false),
21
-
dids: Default::default(),
18
+
impl jacquard_common::IntoStatic for GetServices<'_> {
19
+
type Output = GetServices<'static>;
20
+
fn into_static(self) -> Self::Output {
21
+
GetServices {
22
+
detailed: self.detailed.into_static(),
23
+
dids: self.dids.into_static(),
22
24
}
23
25
}
24
26
}
···
31
33
pub views: Vec<jacquard_common::types::value::Data<'a>>,
32
34
}
33
35
36
+
impl jacquard_common::IntoStatic for GetServicesOutput<'_> {
37
+
type Output = GetServicesOutput<'static>;
38
+
fn into_static(self) -> Self::Output {
39
+
GetServicesOutput {
40
+
views: self.views.into_static(),
41
+
extra_data: self.extra_data.into_static(),
42
+
}
43
+
}
44
+
}
45
+
34
46
impl jacquard_common::types::xrpc::XrpcRequest for GetServices<'_> {
35
47
const NSID: &'static str = "app.bsky.labeler.getServices";
36
48
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
37
49
const OUTPUT_ENCODING: &'static str = "application/json";
38
50
type Output<'de> = GetServicesOutput<'de>;
39
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
51
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
40
52
}
+29
crates/jacquard-api/src/app_bsky/labeler/service.rs
+29
crates/jacquard-api/src/app_bsky/labeler/service.rs
···
45
45
DefsSelfLabels(Box<crate::com_atproto::label::SelfLabels<'a>>),
46
46
}
47
47
48
+
impl jacquard_common::IntoStatic for ServiceRecordLabels<'_> {
49
+
type Output = ServiceRecordLabels<'static>;
50
+
fn into_static(self) -> Self::Output {
51
+
match self {
52
+
ServiceRecordLabels::DefsSelfLabels(v) => {
53
+
ServiceRecordLabels::DefsSelfLabels(v.into_static())
54
+
}
55
+
ServiceRecordLabels::Unknown(v) => {
56
+
ServiceRecordLabels::Unknown(v.into_static())
57
+
}
58
+
}
59
+
}
60
+
}
61
+
48
62
impl jacquard_common::types::collection::Collection for Service<'_> {
49
63
const NSID: &'static str = "app.bsky.labeler.service";
64
+
}
65
+
66
+
impl jacquard_common::IntoStatic for Service<'_> {
67
+
type Output = Service<'static>;
68
+
fn into_static(self) -> Self::Output {
69
+
Service {
70
+
created_at: self.created_at.into_static(),
71
+
labels: self.labels.into_static(),
72
+
policies: self.policies.into_static(),
73
+
reason_types: self.reason_types.into_static(),
74
+
subject_collections: self.subject_collections.into_static(),
75
+
subject_types: self.subject_types.into_static(),
76
+
extra_data: self.extra_data.into_static(),
77
+
}
78
+
}
50
79
}
+87
crates/jacquard-api/src/app_bsky/notification.rs
+87
crates/jacquard-api/src/app_bsky/notification.rs
···
25
25
pub reply: bool,
26
26
}
27
27
28
+
impl jacquard_common::IntoStatic for ActivitySubscription<'_> {
29
+
type Output = ActivitySubscription<'static>;
30
+
fn into_static(self) -> Self::Output {
31
+
ActivitySubscription {
32
+
post: self.post.into_static(),
33
+
reply: self.reply.into_static(),
34
+
extra_data: self.extra_data.into_static(),
35
+
}
36
+
}
37
+
}
38
+
28
39
#[jacquard_derive::lexicon]
29
40
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
30
41
#[serde(rename_all = "camelCase")]
···
32
43
#[serde(borrow)]
33
44
pub include: jacquard_common::CowStr<'a>,
34
45
pub push: bool,
46
+
}
47
+
48
+
impl jacquard_common::IntoStatic for ChatPreference<'_> {
49
+
type Output = ChatPreference<'static>;
50
+
fn into_static(self) -> Self::Output {
51
+
ChatPreference {
52
+
include: self.include.into_static(),
53
+
push: self.push.into_static(),
54
+
extra_data: self.extra_data.into_static(),
55
+
}
56
+
}
35
57
}
36
58
37
59
#[jacquard_derive::lexicon]
···
44
66
pub push: bool,
45
67
}
46
68
69
+
impl jacquard_common::IntoStatic for FilterablePreference<'_> {
70
+
type Output = FilterablePreference<'static>;
71
+
fn into_static(self) -> Self::Output {
72
+
FilterablePreference {
73
+
include: self.include.into_static(),
74
+
list: self.list.into_static(),
75
+
push: self.push.into_static(),
76
+
extra_data: self.extra_data.into_static(),
77
+
}
78
+
}
79
+
}
80
+
47
81
#[jacquard_derive::lexicon]
48
82
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
49
83
#[serde(rename_all = "camelCase")]
···
52
86
pub push: bool,
53
87
}
54
88
89
+
impl jacquard_common::IntoStatic for Preference<'_> {
90
+
type Output = Preference<'static>;
91
+
fn into_static(self) -> Self::Output {
92
+
Preference {
93
+
list: self.list.into_static(),
94
+
push: self.push.into_static(),
95
+
extra_data: self.extra_data.into_static(),
96
+
}
97
+
}
98
+
}
99
+
55
100
#[jacquard_derive::lexicon]
56
101
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
57
102
#[serde(rename_all = "camelCase")]
···
84
129
pub verified: crate::app_bsky::notification::Preference<'a>,
85
130
}
86
131
132
+
impl jacquard_common::IntoStatic for Preferences<'_> {
133
+
type Output = Preferences<'static>;
134
+
fn into_static(self) -> Self::Output {
135
+
Preferences {
136
+
chat: self.chat.into_static(),
137
+
follow: self.follow.into_static(),
138
+
like: self.like.into_static(),
139
+
like_via_repost: self.like_via_repost.into_static(),
140
+
mention: self.mention.into_static(),
141
+
quote: self.quote.into_static(),
142
+
reply: self.reply.into_static(),
143
+
repost: self.repost.into_static(),
144
+
repost_via_repost: self.repost_via_repost.into_static(),
145
+
starterpack_joined: self.starterpack_joined.into_static(),
146
+
subscribed_post: self.subscribed_post.into_static(),
147
+
unverified: self.unverified.into_static(),
148
+
verified: self.verified.into_static(),
149
+
extra_data: self.extra_data.into_static(),
150
+
}
151
+
}
152
+
}
153
+
87
154
#[jacquard_derive::lexicon]
88
155
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
89
156
#[serde(rename_all = "camelCase")]
90
157
pub struct RecordDeleted<'a> {}
158
+
impl jacquard_common::IntoStatic for RecordDeleted<'_> {
159
+
type Output = RecordDeleted<'static>;
160
+
fn into_static(self) -> Self::Output {
161
+
RecordDeleted {
162
+
extra_data: self.extra_data.into_static(),
163
+
}
164
+
}
165
+
}
166
+
91
167
///Object used to store activity subscription data in stash.
92
168
#[jacquard_derive::lexicon]
93
169
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
97
173
pub activity_subscription: crate::app_bsky::notification::ActivitySubscription<'a>,
98
174
#[serde(borrow)]
99
175
pub subject: jacquard_common::types::string::Did<'a>,
176
+
}
177
+
178
+
impl jacquard_common::IntoStatic for SubjectActivitySubscription<'_> {
179
+
type Output = SubjectActivitySubscription<'static>;
180
+
fn into_static(self) -> Self::Output {
181
+
SubjectActivitySubscription {
182
+
activity_subscription: self.activity_subscription.into_static(),
183
+
subject: self.subject.into_static(),
184
+
extra_data: self.extra_data.into_static(),
185
+
}
186
+
}
100
187
}
+10
crates/jacquard-api/src/app_bsky/notification/declaration.rs
+10
crates/jacquard-api/src/app_bsky/notification/declaration.rs
···
17
17
18
18
impl jacquard_common::types::collection::Collection for Declaration<'_> {
19
19
const NSID: &'static str = "app.bsky.notification.declaration";
20
+
}
21
+
22
+
impl jacquard_common::IntoStatic for Declaration<'_> {
23
+
type Output = Declaration<'static>;
24
+
fn into_static(self) -> Self::Output {
25
+
Declaration {
26
+
allow_subscriptions: self.allow_subscriptions.into_static(),
27
+
extra_data: self.extra_data.into_static(),
28
+
}
29
+
}
20
30
}
+18
-1
crates/jacquard-api/src/app_bsky/notification/get_preferences.rs
+18
-1
crates/jacquard-api/src/app_bsky/notification/get_preferences.rs
···
8
8
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetPreferences {}
11
+
impl jacquard_common::IntoStatic for GetPreferences {
12
+
type Output = GetPreferences;
13
+
fn into_static(self) -> Self::Output {
14
+
self
15
+
}
16
+
}
17
+
11
18
#[jacquard_derive::lexicon]
12
19
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
13
20
#[serde(rename_all = "camelCase")]
···
16
23
pub preferences: crate::app_bsky::notification::Preferences<'a>,
17
24
}
18
25
26
+
impl jacquard_common::IntoStatic for GetPreferencesOutput<'_> {
27
+
type Output = GetPreferencesOutput<'static>;
28
+
fn into_static(self) -> Self::Output {
29
+
GetPreferencesOutput {
30
+
preferences: self.preferences.into_static(),
31
+
extra_data: self.extra_data.into_static(),
32
+
}
33
+
}
34
+
}
35
+
19
36
impl jacquard_common::types::xrpc::XrpcRequest for GetPreferences {
20
37
const NSID: &'static str = "app.bsky.notification.getPreferences";
21
38
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
22
39
const OUTPUT_ENCODING: &'static str = "application/json";
23
40
type Output<'de> = GetPreferencesOutput<'de>;
24
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
41
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
25
42
}
+18
-1
crates/jacquard-api/src/app_bsky/notification/get_unread_count.rs
+18
-1
crates/jacquard-api/src/app_bsky/notification/get_unread_count.rs
···
14
14
pub seen_at: std::option::Option<jacquard_common::types::string::Datetime>,
15
15
}
16
16
17
+
impl jacquard_common::IntoStatic for GetUnreadCount {
18
+
type Output = GetUnreadCount;
19
+
fn into_static(self) -> Self::Output {
20
+
self
21
+
}
22
+
}
23
+
17
24
#[jacquard_derive::lexicon]
18
25
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
19
26
#[serde(rename_all = "camelCase")]
···
21
28
pub count: i64,
22
29
}
23
30
31
+
impl jacquard_common::IntoStatic for GetUnreadCountOutput<'_> {
32
+
type Output = GetUnreadCountOutput<'static>;
33
+
fn into_static(self) -> Self::Output {
34
+
GetUnreadCountOutput {
35
+
count: self.count.into_static(),
36
+
extra_data: self.extra_data.into_static(),
37
+
}
38
+
}
39
+
}
40
+
24
41
impl jacquard_common::types::xrpc::XrpcRequest for GetUnreadCount {
25
42
const NSID: &'static str = "app.bsky.notification.getUnreadCount";
26
43
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
27
44
const OUTPUT_ENCODING: &'static str = "application/json";
28
45
type Output<'de> = GetUnreadCountOutput<'de>;
29
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
46
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
30
47
}
+20
-7
crates/jacquard-api/src/app_bsky/notification/list_activity_subscriptions.rs
+20
-7
crates/jacquard-api/src/app_bsky/notification/list_activity_subscriptions.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct ListActivitySubscriptions<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
12
#[serde(borrow)]
13
13
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
14
+
///(default: 50, min: 1, max: 100)
14
15
#[serde(skip_serializing_if = "std::option::Option::is_none")]
15
16
pub limit: std::option::Option<i64>,
16
17
}
17
18
18
-
impl Default for ListActivitySubscriptions<'_> {
19
-
fn default() -> Self {
20
-
Self {
21
-
cursor: Default::default(),
22
-
limit: Some(50i64),
19
+
impl jacquard_common::IntoStatic for ListActivitySubscriptions<'_> {
20
+
type Output = ListActivitySubscriptions<'static>;
21
+
fn into_static(self) -> Self::Output {
22
+
ListActivitySubscriptions {
23
+
cursor: self.cursor.into_static(),
24
+
limit: self.limit.into_static(),
23
25
}
24
26
}
25
27
}
···
35
37
pub subscriptions: Vec<crate::app_bsky::actor::ProfileView<'a>>,
36
38
}
37
39
40
+
impl jacquard_common::IntoStatic for ListActivitySubscriptionsOutput<'_> {
41
+
type Output = ListActivitySubscriptionsOutput<'static>;
42
+
fn into_static(self) -> Self::Output {
43
+
ListActivitySubscriptionsOutput {
44
+
cursor: self.cursor.into_static(),
45
+
subscriptions: self.subscriptions.into_static(),
46
+
extra_data: self.extra_data.into_static(),
47
+
}
48
+
}
49
+
}
50
+
38
51
impl jacquard_common::types::xrpc::XrpcRequest for ListActivitySubscriptions<'_> {
39
52
const NSID: &'static str = "app.bsky.notification.listActivitySubscriptions";
40
53
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
41
54
const OUTPUT_ENCODING: &'static str = "application/json";
42
55
type Output<'de> = ListActivitySubscriptionsOutput<'de>;
43
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
56
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
44
57
}
+43
-10
crates/jacquard-api/src/app_bsky/notification/list_notifications.rs
+43
-10
crates/jacquard-api/src/app_bsky/notification/list_notifications.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct ListNotifications<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
12
#[serde(borrow)]
13
13
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
14
+
///(default: 50, min: 1, max: 100)
14
15
#[serde(skip_serializing_if = "std::option::Option::is_none")]
15
16
pub limit: std::option::Option<i64>,
16
17
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
22
23
pub seen_at: std::option::Option<jacquard_common::types::string::Datetime>,
23
24
}
24
25
25
-
impl Default for ListNotifications<'_> {
26
-
fn default() -> Self {
27
-
Self {
28
-
cursor: Default::default(),
29
-
limit: Some(50i64),
30
-
priority: Default::default(),
31
-
reasons: Default::default(),
32
-
seen_at: Default::default(),
26
+
impl jacquard_common::IntoStatic for ListNotifications<'_> {
27
+
type Output = ListNotifications<'static>;
28
+
fn into_static(self) -> Self::Output {
29
+
ListNotifications {
30
+
cursor: self.cursor.into_static(),
31
+
limit: self.limit.into_static(),
32
+
priority: self.priority.into_static(),
33
+
reasons: self.reasons.into_static(),
34
+
seen_at: self.seen_at.into_static(),
33
35
}
34
36
}
35
37
}
···
49
51
pub seen_at: std::option::Option<jacquard_common::types::string::Datetime>,
50
52
}
51
53
54
+
impl jacquard_common::IntoStatic for ListNotificationsOutput<'_> {
55
+
type Output = ListNotificationsOutput<'static>;
56
+
fn into_static(self) -> Self::Output {
57
+
ListNotificationsOutput {
58
+
cursor: self.cursor.into_static(),
59
+
notifications: self.notifications.into_static(),
60
+
priority: self.priority.into_static(),
61
+
seen_at: self.seen_at.into_static(),
62
+
extra_data: self.extra_data.into_static(),
63
+
}
64
+
}
65
+
}
66
+
52
67
impl jacquard_common::types::xrpc::XrpcRequest for ListNotifications<'_> {
53
68
const NSID: &'static str = "app.bsky.notification.listNotifications";
54
69
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
55
70
const OUTPUT_ENCODING: &'static str = "application/json";
56
71
type Output<'de> = ListNotificationsOutput<'de>;
57
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
72
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
58
73
}
59
74
60
75
#[jacquard_derive::lexicon]
···
80
95
pub record: jacquard_common::types::value::Data<'a>,
81
96
#[serde(borrow)]
82
97
pub uri: jacquard_common::types::string::AtUri<'a>,
98
+
}
99
+
100
+
impl jacquard_common::IntoStatic for Notification<'_> {
101
+
type Output = Notification<'static>;
102
+
fn into_static(self) -> Self::Output {
103
+
Notification {
104
+
author: self.author.into_static(),
105
+
cid: self.cid.into_static(),
106
+
indexed_at: self.indexed_at.into_static(),
107
+
is_read: self.is_read.into_static(),
108
+
labels: self.labels.into_static(),
109
+
reason: self.reason.into_static(),
110
+
reason_subject: self.reason_subject.into_static(),
111
+
record: self.record.into_static(),
112
+
uri: self.uri.into_static(),
113
+
extra_data: self.extra_data.into_static(),
114
+
}
115
+
}
83
116
}
+23
-1
crates/jacquard-api/src/app_bsky/notification/put_activity_subscription.rs
+23
-1
crates/jacquard-api/src/app_bsky/notification/put_activity_subscription.rs
···
15
15
pub subject: jacquard_common::types::string::Did<'a>,
16
16
}
17
17
18
+
impl jacquard_common::IntoStatic for PutActivitySubscription<'_> {
19
+
type Output = PutActivitySubscription<'static>;
20
+
fn into_static(self) -> Self::Output {
21
+
PutActivitySubscription {
22
+
activity_subscription: self.activity_subscription.into_static(),
23
+
subject: self.subject.into_static(),
24
+
extra_data: self.extra_data.into_static(),
25
+
}
26
+
}
27
+
}
28
+
18
29
#[jacquard_derive::lexicon]
19
30
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
20
31
#[serde(rename_all = "camelCase")]
···
28
39
pub subject: jacquard_common::types::string::Did<'a>,
29
40
}
30
41
42
+
impl jacquard_common::IntoStatic for PutActivitySubscriptionOutput<'_> {
43
+
type Output = PutActivitySubscriptionOutput<'static>;
44
+
fn into_static(self) -> Self::Output {
45
+
PutActivitySubscriptionOutput {
46
+
activity_subscription: self.activity_subscription.into_static(),
47
+
subject: self.subject.into_static(),
48
+
extra_data: self.extra_data.into_static(),
49
+
}
50
+
}
51
+
}
52
+
31
53
impl jacquard_common::types::xrpc::XrpcRequest for PutActivitySubscription<'_> {
32
54
const NSID: &'static str = "app.bsky.notification.putActivitySubscription";
33
55
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
35
57
);
36
58
const OUTPUT_ENCODING: &'static str = "application/json";
37
59
type Output<'de> = PutActivitySubscriptionOutput<'de>;
38
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
60
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
39
61
}
+11
-1
crates/jacquard-api/src/app_bsky/notification/put_preferences.rs
+11
-1
crates/jacquard-api/src/app_bsky/notification/put_preferences.rs
···
12
12
pub priority: bool,
13
13
}
14
14
15
+
impl jacquard_common::IntoStatic for PutPreferences<'_> {
16
+
type Output = PutPreferences<'static>;
17
+
fn into_static(self) -> Self::Output {
18
+
PutPreferences {
19
+
priority: self.priority.into_static(),
20
+
extra_data: self.extra_data.into_static(),
21
+
}
22
+
}
23
+
}
24
+
15
25
impl jacquard_common::types::xrpc::XrpcRequest for PutPreferences<'_> {
16
26
const NSID: &'static str = "app.bsky.notification.putPreferences";
17
27
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
19
29
);
20
30
const OUTPUT_ENCODING: &'static str = "application/json";
21
31
type Output<'de> = ();
22
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
32
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
23
33
}
+33
-1
crates/jacquard-api/src/app_bsky/notification/put_preferences_v2.rs
+33
-1
crates/jacquard-api/src/app_bsky/notification/put_preferences_v2.rs
···
70
70
pub verified: std::option::Option<crate::app_bsky::notification::Preference<'a>>,
71
71
}
72
72
73
+
impl jacquard_common::IntoStatic for PutPreferencesV2<'_> {
74
+
type Output = PutPreferencesV2<'static>;
75
+
fn into_static(self) -> Self::Output {
76
+
PutPreferencesV2 {
77
+
chat: self.chat.into_static(),
78
+
follow: self.follow.into_static(),
79
+
like: self.like.into_static(),
80
+
like_via_repost: self.like_via_repost.into_static(),
81
+
mention: self.mention.into_static(),
82
+
quote: self.quote.into_static(),
83
+
reply: self.reply.into_static(),
84
+
repost: self.repost.into_static(),
85
+
repost_via_repost: self.repost_via_repost.into_static(),
86
+
starterpack_joined: self.starterpack_joined.into_static(),
87
+
subscribed_post: self.subscribed_post.into_static(),
88
+
unverified: self.unverified.into_static(),
89
+
verified: self.verified.into_static(),
90
+
extra_data: self.extra_data.into_static(),
91
+
}
92
+
}
93
+
}
94
+
73
95
#[jacquard_derive::lexicon]
74
96
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
75
97
#[serde(rename_all = "camelCase")]
···
78
100
pub preferences: crate::app_bsky::notification::Preferences<'a>,
79
101
}
80
102
103
+
impl jacquard_common::IntoStatic for PutPreferencesV2Output<'_> {
104
+
type Output = PutPreferencesV2Output<'static>;
105
+
fn into_static(self) -> Self::Output {
106
+
PutPreferencesV2Output {
107
+
preferences: self.preferences.into_static(),
108
+
extra_data: self.extra_data.into_static(),
109
+
}
110
+
}
111
+
}
112
+
81
113
impl jacquard_common::types::xrpc::XrpcRequest for PutPreferencesV2<'_> {
82
114
const NSID: &'static str = "app.bsky.notification.putPreferencesV2";
83
115
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
85
117
);
86
118
const OUTPUT_ENCODING: &'static str = "application/json";
87
119
type Output<'de> = PutPreferencesV2Output<'de>;
88
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
120
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
89
121
}
+15
-1
crates/jacquard-api/src/app_bsky/notification/register_push.rs
+15
-1
crates/jacquard-api/src/app_bsky/notification/register_push.rs
···
22
22
pub token: jacquard_common::CowStr<'a>,
23
23
}
24
24
25
+
impl jacquard_common::IntoStatic for RegisterPush<'_> {
26
+
type Output = RegisterPush<'static>;
27
+
fn into_static(self) -> Self::Output {
28
+
RegisterPush {
29
+
age_restricted: self.age_restricted.into_static(),
30
+
app_id: self.app_id.into_static(),
31
+
platform: self.platform.into_static(),
32
+
service_did: self.service_did.into_static(),
33
+
token: self.token.into_static(),
34
+
extra_data: self.extra_data.into_static(),
35
+
}
36
+
}
37
+
}
38
+
25
39
impl jacquard_common::types::xrpc::XrpcRequest for RegisterPush<'_> {
26
40
const NSID: &'static str = "app.bsky.notification.registerPush";
27
41
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
29
43
);
30
44
const OUTPUT_ENCODING: &'static str = "application/json";
31
45
type Output<'de> = ();
32
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
46
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
33
47
}
+14
-1
crates/jacquard-api/src/app_bsky/notification/unregister_push.rs
+14
-1
crates/jacquard-api/src/app_bsky/notification/unregister_push.rs
···
19
19
pub token: jacquard_common::CowStr<'a>,
20
20
}
21
21
22
+
impl jacquard_common::IntoStatic for UnregisterPush<'_> {
23
+
type Output = UnregisterPush<'static>;
24
+
fn into_static(self) -> Self::Output {
25
+
UnregisterPush {
26
+
app_id: self.app_id.into_static(),
27
+
platform: self.platform.into_static(),
28
+
service_did: self.service_did.into_static(),
29
+
token: self.token.into_static(),
30
+
extra_data: self.extra_data.into_static(),
31
+
}
32
+
}
33
+
}
34
+
22
35
impl jacquard_common::types::xrpc::XrpcRequest for UnregisterPush<'_> {
23
36
const NSID: &'static str = "app.bsky.notification.unregisterPush";
24
37
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
26
39
);
27
40
const OUTPUT_ENCODING: &'static str = "application/json";
28
41
type Output<'de> = ();
29
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
42
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
30
43
}
+11
-1
crates/jacquard-api/src/app_bsky/notification/update_seen.rs
+11
-1
crates/jacquard-api/src/app_bsky/notification/update_seen.rs
···
12
12
pub seen_at: jacquard_common::types::string::Datetime,
13
13
}
14
14
15
+
impl jacquard_common::IntoStatic for UpdateSeen<'_> {
16
+
type Output = UpdateSeen<'static>;
17
+
fn into_static(self) -> Self::Output {
18
+
UpdateSeen {
19
+
seen_at: self.seen_at.into_static(),
20
+
extra_data: self.extra_data.into_static(),
21
+
}
22
+
}
23
+
}
24
+
15
25
impl jacquard_common::types::xrpc::XrpcRequest for UpdateSeen<'_> {
16
26
const NSID: &'static str = "app.bsky.notification.updateSeen";
17
27
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
19
29
);
20
30
const OUTPUT_ENCODING: &'static str = "application/json";
21
31
type Output<'de> = ();
22
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
32
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
23
33
}
+52
crates/jacquard-api/src/app_bsky/richtext/facet.rs
+52
crates/jacquard-api/src/app_bsky/richtext/facet.rs
···
14
14
pub byte_start: i64,
15
15
}
16
16
17
+
impl jacquard_common::IntoStatic for ByteSlice<'_> {
18
+
type Output = ByteSlice<'static>;
19
+
fn into_static(self) -> Self::Output {
20
+
ByteSlice {
21
+
byte_end: self.byte_end.into_static(),
22
+
byte_start: self.byte_start.into_static(),
23
+
extra_data: self.extra_data.into_static(),
24
+
}
25
+
}
26
+
}
27
+
17
28
///Facet feature for a URL. The text URL may have been simplified or truncated, but the facet reference should be a complete URL.
18
29
#[jacquard_derive::lexicon]
19
30
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
23
34
pub uri: jacquard_common::types::string::Uri<'a>,
24
35
}
25
36
37
+
impl jacquard_common::IntoStatic for Link<'_> {
38
+
type Output = Link<'static>;
39
+
fn into_static(self) -> Self::Output {
40
+
Link {
41
+
uri: self.uri.into_static(),
42
+
extra_data: self.extra_data.into_static(),
43
+
}
44
+
}
45
+
}
46
+
26
47
///Annotation of a sub-string within rich text.
27
48
#[jacquard_derive::lexicon]
28
49
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
34
55
pub index: crate::app_bsky::richtext::facet::ByteSlice<'a>,
35
56
}
36
57
58
+
impl jacquard_common::IntoStatic for Facet<'_> {
59
+
type Output = Facet<'static>;
60
+
fn into_static(self) -> Self::Output {
61
+
Facet {
62
+
features: self.features.into_static(),
63
+
index: self.index.into_static(),
64
+
extra_data: self.extra_data.into_static(),
65
+
}
66
+
}
67
+
}
68
+
37
69
///Facet feature for mention of another account. The text is usually a handle, including a '@' prefix, but the facet reference is a DID.
38
70
#[jacquard_derive::lexicon]
39
71
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
43
75
pub did: jacquard_common::types::string::Did<'a>,
44
76
}
45
77
78
+
impl jacquard_common::IntoStatic for Mention<'_> {
79
+
type Output = Mention<'static>;
80
+
fn into_static(self) -> Self::Output {
81
+
Mention {
82
+
did: self.did.into_static(),
83
+
extra_data: self.extra_data.into_static(),
84
+
}
85
+
}
86
+
}
87
+
46
88
///Facet feature for a hashtag. The text usually includes a '#' prefix, but the facet reference should not (except in the case of 'double hash tags').
47
89
#[jacquard_derive::lexicon]
48
90
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
50
92
pub struct Tag<'a> {
51
93
#[serde(borrow)]
52
94
pub tag: jacquard_common::CowStr<'a>,
95
+
}
96
+
97
+
impl jacquard_common::IntoStatic for Tag<'_> {
98
+
type Output = Tag<'static>;
99
+
fn into_static(self) -> Self::Output {
100
+
Tag {
101
+
tag: self.tag.into_static(),
102
+
extra_data: self.extra_data.into_static(),
103
+
}
104
+
}
53
105
}
+148
crates/jacquard-api/src/app_bsky/unspecced.rs
+148
crates/jacquard-api/src/app_bsky/unspecced.rs
···
63
63
pub status: jacquard_common::CowStr<'a>,
64
64
}
65
65
66
+
impl jacquard_common::IntoStatic for AgeAssuranceEvent<'_> {
67
+
type Output = AgeAssuranceEvent<'static>;
68
+
fn into_static(self) -> Self::Output {
69
+
AgeAssuranceEvent {
70
+
attempt_id: self.attempt_id.into_static(),
71
+
complete_ip: self.complete_ip.into_static(),
72
+
complete_ua: self.complete_ua.into_static(),
73
+
created_at: self.created_at.into_static(),
74
+
email: self.email.into_static(),
75
+
init_ip: self.init_ip.into_static(),
76
+
init_ua: self.init_ua.into_static(),
77
+
status: self.status.into_static(),
78
+
extra_data: self.extra_data.into_static(),
79
+
}
80
+
}
81
+
}
82
+
66
83
///The computed state of the age assurance process, returned to the user in question on certain authenticated requests.
67
84
#[jacquard_derive::lexicon]
68
85
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
76
93
pub status: jacquard_common::CowStr<'a>,
77
94
}
78
95
96
+
impl jacquard_common::IntoStatic for AgeAssuranceState<'_> {
97
+
type Output = AgeAssuranceState<'static>;
98
+
fn into_static(self) -> Self::Output {
99
+
AgeAssuranceState {
100
+
last_initiated_at: self.last_initiated_at.into_static(),
101
+
status: self.status.into_static(),
102
+
extra_data: self.extra_data.into_static(),
103
+
}
104
+
}
105
+
}
106
+
79
107
#[jacquard_derive::lexicon]
80
108
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
81
109
#[serde(rename_all = "camelCase")]
···
84
112
pub did: jacquard_common::types::string::Did<'a>,
85
113
}
86
114
115
+
impl jacquard_common::IntoStatic for SkeletonSearchActor<'_> {
116
+
type Output = SkeletonSearchActor<'static>;
117
+
fn into_static(self) -> Self::Output {
118
+
SkeletonSearchActor {
119
+
did: self.did.into_static(),
120
+
extra_data: self.extra_data.into_static(),
121
+
}
122
+
}
123
+
}
124
+
87
125
#[jacquard_derive::lexicon]
88
126
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
89
127
#[serde(rename_all = "camelCase")]
···
92
130
pub uri: jacquard_common::types::string::AtUri<'a>,
93
131
}
94
132
133
+
impl jacquard_common::IntoStatic for SkeletonSearchPost<'_> {
134
+
type Output = SkeletonSearchPost<'static>;
135
+
fn into_static(self) -> Self::Output {
136
+
SkeletonSearchPost {
137
+
uri: self.uri.into_static(),
138
+
extra_data: self.extra_data.into_static(),
139
+
}
140
+
}
141
+
}
142
+
95
143
#[jacquard_derive::lexicon]
96
144
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
97
145
#[serde(rename_all = "camelCase")]
···
100
148
pub uri: jacquard_common::types::string::AtUri<'a>,
101
149
}
102
150
151
+
impl jacquard_common::IntoStatic for SkeletonSearchStarterPack<'_> {
152
+
type Output = SkeletonSearchStarterPack<'static>;
153
+
fn into_static(self) -> Self::Output {
154
+
SkeletonSearchStarterPack {
155
+
uri: self.uri.into_static(),
156
+
extra_data: self.extra_data.into_static(),
157
+
}
158
+
}
159
+
}
160
+
103
161
#[jacquard_derive::lexicon]
104
162
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
105
163
#[serde(rename_all = "camelCase")]
···
122
180
pub topic: jacquard_common::CowStr<'a>,
123
181
}
124
182
183
+
impl jacquard_common::IntoStatic for SkeletonTrend<'_> {
184
+
type Output = SkeletonTrend<'static>;
185
+
fn into_static(self) -> Self::Output {
186
+
SkeletonTrend {
187
+
category: self.category.into_static(),
188
+
dids: self.dids.into_static(),
189
+
display_name: self.display_name.into_static(),
190
+
link: self.link.into_static(),
191
+
post_count: self.post_count.into_static(),
192
+
started_at: self.started_at.into_static(),
193
+
status: self.status.into_static(),
194
+
topic: self.topic.into_static(),
195
+
extra_data: self.extra_data.into_static(),
196
+
}
197
+
}
198
+
}
199
+
125
200
#[jacquard_derive::lexicon]
126
201
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
127
202
#[serde(rename_all = "camelCase")]
···
130
205
pub author: crate::app_bsky::feed::BlockedAuthor<'a>,
131
206
}
132
207
208
+
impl jacquard_common::IntoStatic for ThreadItemBlocked<'_> {
209
+
type Output = ThreadItemBlocked<'static>;
210
+
fn into_static(self) -> Self::Output {
211
+
ThreadItemBlocked {
212
+
author: self.author.into_static(),
213
+
extra_data: self.extra_data.into_static(),
214
+
}
215
+
}
216
+
}
217
+
133
218
#[jacquard_derive::lexicon]
134
219
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
135
220
#[serde(rename_all = "camelCase")]
136
221
pub struct ThreadItemNoUnauthenticated<'a> {}
222
+
impl jacquard_common::IntoStatic for ThreadItemNoUnauthenticated<'_> {
223
+
type Output = ThreadItemNoUnauthenticated<'static>;
224
+
fn into_static(self) -> Self::Output {
225
+
ThreadItemNoUnauthenticated {
226
+
extra_data: self.extra_data.into_static(),
227
+
}
228
+
}
229
+
}
230
+
137
231
#[jacquard_derive::lexicon]
138
232
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
139
233
#[serde(rename_all = "camelCase")]
140
234
pub struct ThreadItemNotFound<'a> {}
235
+
impl jacquard_common::IntoStatic for ThreadItemNotFound<'_> {
236
+
type Output = ThreadItemNotFound<'static>;
237
+
fn into_static(self) -> Self::Output {
238
+
ThreadItemNotFound {
239
+
extra_data: self.extra_data.into_static(),
240
+
}
241
+
}
242
+
}
243
+
141
244
#[jacquard_derive::lexicon]
142
245
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
143
246
#[serde(rename_all = "camelCase")]
···
156
259
pub post: crate::app_bsky::feed::PostView<'a>,
157
260
}
158
261
262
+
impl jacquard_common::IntoStatic for ThreadItemPost<'_> {
263
+
type Output = ThreadItemPost<'static>;
264
+
fn into_static(self) -> Self::Output {
265
+
ThreadItemPost {
266
+
hidden_by_threadgate: self.hidden_by_threadgate.into_static(),
267
+
more_parents: self.more_parents.into_static(),
268
+
more_replies: self.more_replies.into_static(),
269
+
muted_by_viewer: self.muted_by_viewer.into_static(),
270
+
op_thread: self.op_thread.into_static(),
271
+
post: self.post.into_static(),
272
+
extra_data: self.extra_data.into_static(),
273
+
}
274
+
}
275
+
}
276
+
159
277
#[jacquard_derive::lexicon]
160
278
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
161
279
#[serde(rename_all = "camelCase")]
···
178
296
pub topic: jacquard_common::CowStr<'a>,
179
297
}
180
298
299
+
impl jacquard_common::IntoStatic for TrendView<'_> {
300
+
type Output = TrendView<'static>;
301
+
fn into_static(self) -> Self::Output {
302
+
TrendView {
303
+
actors: self.actors.into_static(),
304
+
category: self.category.into_static(),
305
+
display_name: self.display_name.into_static(),
306
+
link: self.link.into_static(),
307
+
post_count: self.post_count.into_static(),
308
+
started_at: self.started_at.into_static(),
309
+
status: self.status.into_static(),
310
+
topic: self.topic.into_static(),
311
+
extra_data: self.extra_data.into_static(),
312
+
}
313
+
}
314
+
}
315
+
181
316
#[jacquard_derive::lexicon]
182
317
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
183
318
#[serde(rename_all = "camelCase")]
···
192
327
pub link: jacquard_common::CowStr<'a>,
193
328
#[serde(borrow)]
194
329
pub topic: jacquard_common::CowStr<'a>,
330
+
}
331
+
332
+
impl jacquard_common::IntoStatic for TrendingTopic<'_> {
333
+
type Output = TrendingTopic<'static>;
334
+
fn into_static(self) -> Self::Output {
335
+
TrendingTopic {
336
+
description: self.description.into_static(),
337
+
display_name: self.display_name.into_static(),
338
+
link: self.link.into_static(),
339
+
topic: self.topic.into_static(),
340
+
extra_data: self.extra_data.into_static(),
341
+
}
342
+
}
195
343
}
+11
-1
crates/jacquard-api/src/app_bsky/unspecced/get_age_assurance_state.rs
+11
-1
crates/jacquard-api/src/app_bsky/unspecced/get_age_assurance_state.rs
···
14
14
pub value: crate::app_bsky::unspecced::AgeAssuranceState<'a>,
15
15
}
16
16
17
+
impl jacquard_common::IntoStatic for GetAgeAssuranceStateOutput<'_> {
18
+
type Output = GetAgeAssuranceStateOutput<'static>;
19
+
fn into_static(self) -> Self::Output {
20
+
GetAgeAssuranceStateOutput {
21
+
value: self.value.into_static(),
22
+
extra_data: self.extra_data.into_static(),
23
+
}
24
+
}
25
+
}
26
+
17
27
/// XRPC request marker type
18
28
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]
19
29
pub struct GetAgeAssuranceState;
···
22
32
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
23
33
const OUTPUT_ENCODING: &'static str = "application/json";
24
34
type Output<'de> = GetAgeAssuranceStateOutput<'de>;
25
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
35
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
26
36
}
+23
-1
crates/jacquard-api/src/app_bsky/unspecced/get_config.rs
+23
-1
crates/jacquard-api/src/app_bsky/unspecced/get_config.rs
···
15
15
pub domains: Vec<jacquard_common::CowStr<'a>>,
16
16
}
17
17
18
+
impl jacquard_common::IntoStatic for LiveNowConfig<'_> {
19
+
type Output = LiveNowConfig<'static>;
20
+
fn into_static(self) -> Self::Output {
21
+
LiveNowConfig {
22
+
did: self.did.into_static(),
23
+
domains: self.domains.into_static(),
24
+
extra_data: self.extra_data.into_static(),
25
+
}
26
+
}
27
+
}
28
+
18
29
#[jacquard_derive::lexicon]
19
30
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
20
31
#[serde(rename_all = "camelCase")]
···
26
37
pub live_now: std::option::Option<Vec<jacquard_common::types::value::Data<'a>>>,
27
38
}
28
39
40
+
impl jacquard_common::IntoStatic for GetConfigOutput<'_> {
41
+
type Output = GetConfigOutput<'static>;
42
+
fn into_static(self) -> Self::Output {
43
+
GetConfigOutput {
44
+
check_email_confirmed: self.check_email_confirmed.into_static(),
45
+
live_now: self.live_now.into_static(),
46
+
extra_data: self.extra_data.into_static(),
47
+
}
48
+
}
49
+
}
50
+
29
51
/// XRPC request marker type
30
52
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]
31
53
pub struct GetConfig;
···
34
56
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
35
57
const OUTPUT_ENCODING: &'static str = "application/json";
36
58
type Output<'de> = GetConfigOutput<'de>;
37
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
59
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
38
60
}
+23
-4
crates/jacquard-api/src/app_bsky/unspecced/get_onboarding_suggested_starter_packs.rs
+23
-4
crates/jacquard-api/src/app_bsky/unspecced/get_onboarding_suggested_starter_packs.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetOnboardingSuggestedStarterPacks {
11
+
///(default: 10, min: 1, max: 25)
11
12
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
13
pub limit: std::option::Option<i64>,
13
14
}
14
15
16
+
impl jacquard_common::IntoStatic for GetOnboardingSuggestedStarterPacks {
17
+
type Output = GetOnboardingSuggestedStarterPacks;
18
+
fn into_static(self) -> Self::Output {
19
+
self
20
+
}
21
+
}
22
+
15
23
#[jacquard_derive::lexicon]
16
24
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
25
#[serde(rename_all = "camelCase")]
···
20
28
pub starter_packs: Vec<crate::app_bsky::graph::StarterPackView<'a>>,
21
29
}
22
30
31
+
impl jacquard_common::IntoStatic for GetOnboardingSuggestedStarterPacksOutput<'_> {
32
+
type Output = GetOnboardingSuggestedStarterPacksOutput<'static>;
33
+
fn into_static(self) -> Self::Output {
34
+
GetOnboardingSuggestedStarterPacksOutput {
35
+
starter_packs: self.starter_packs.into_static(),
36
+
extra_data: self.extra_data.into_static(),
37
+
}
38
+
}
39
+
}
40
+
23
41
impl jacquard_common::types::xrpc::XrpcRequest for GetOnboardingSuggestedStarterPacks {
24
42
const NSID: &'static str = "app.bsky.unspecced.getOnboardingSuggestedStarterPacks";
25
-
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
43
+
const METHOD: jacquard_common::types::xrpc::XrpcMethod =
44
+
jacquard_common::types::xrpc::XrpcMethod::Query;
26
45
const OUTPUT_ENCODING: &'static str = "application/json";
27
46
type Output<'de> = GetOnboardingSuggestedStarterPacksOutput<'de>;
28
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
29
-
}
47
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
48
+
}
+20
-7
crates/jacquard-api/src/app_bsky/unspecced/get_onboarding_suggested_starter_packs_skeleton.rs
+20
-7
crates/jacquard-api/src/app_bsky/unspecced/get_onboarding_suggested_starter_packs_skeleton.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetOnboardingSuggestedStarterPacksSkeleton<'a> {
11
+
///(default: 10, min: 1, max: 25)
11
12
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
13
pub limit: std::option::Option<i64>,
13
14
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
15
16
pub viewer: std::option::Option<jacquard_common::types::string::Did<'a>>,
16
17
}
17
18
18
-
impl Default for GetOnboardingSuggestedStarterPacksSkeleton<'_> {
19
-
fn default() -> Self {
20
-
Self {
21
-
limit: Some(10i64),
22
-
viewer: Default::default(),
19
+
impl jacquard_common::IntoStatic for GetOnboardingSuggestedStarterPacksSkeleton<'_> {
20
+
type Output = GetOnboardingSuggestedStarterPacksSkeleton<'static>;
21
+
fn into_static(self) -> Self::Output {
22
+
GetOnboardingSuggestedStarterPacksSkeleton {
23
+
limit: self.limit.into_static(),
24
+
viewer: self.viewer.into_static(),
23
25
}
24
26
}
25
27
}
···
32
34
pub starter_packs: Vec<jacquard_common::types::string::AtUri<'a>>,
33
35
}
34
36
37
+
impl jacquard_common::IntoStatic
38
+
for GetOnboardingSuggestedStarterPacksSkeletonOutput<'_> {
39
+
type Output = GetOnboardingSuggestedStarterPacksSkeletonOutput<'static>;
40
+
fn into_static(self) -> Self::Output {
41
+
GetOnboardingSuggestedStarterPacksSkeletonOutput {
42
+
starter_packs: self.starter_packs.into_static(),
43
+
extra_data: self.extra_data.into_static(),
44
+
}
45
+
}
46
+
}
47
+
35
48
impl jacquard_common::types::xrpc::XrpcRequest
36
49
for GetOnboardingSuggestedStarterPacksSkeleton<'_> {
37
50
const NSID: &'static str = "app.bsky.unspecced.getOnboardingSuggestedStarterPacksSkeleton";
38
51
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
39
52
const OUTPUT_ENCODING: &'static str = "application/json";
40
53
type Output<'de> = GetOnboardingSuggestedStarterPacksSkeletonOutput<'de>;
41
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
54
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
42
55
}
+21
-8
crates/jacquard-api/src/app_bsky/unspecced/get_popular_feed_generators.rs
+21
-8
crates/jacquard-api/src/app_bsky/unspecced/get_popular_feed_generators.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetPopularFeedGenerators<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
12
#[serde(borrow)]
13
13
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
14
+
///(default: 50, min: 1, max: 100)
14
15
#[serde(skip_serializing_if = "std::option::Option::is_none")]
15
16
pub limit: std::option::Option<i64>,
16
17
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
18
19
pub query: std::option::Option<jacquard_common::CowStr<'a>>,
19
20
}
20
21
21
-
impl Default for GetPopularFeedGenerators<'_> {
22
-
fn default() -> Self {
23
-
Self {
24
-
cursor: Default::default(),
25
-
limit: Some(50i64),
26
-
query: Default::default(),
22
+
impl jacquard_common::IntoStatic for GetPopularFeedGenerators<'_> {
23
+
type Output = GetPopularFeedGenerators<'static>;
24
+
fn into_static(self) -> Self::Output {
25
+
GetPopularFeedGenerators {
26
+
cursor: self.cursor.into_static(),
27
+
limit: self.limit.into_static(),
28
+
query: self.query.into_static(),
27
29
}
28
30
}
29
31
}
···
39
41
pub feeds: Vec<crate::app_bsky::feed::GeneratorView<'a>>,
40
42
}
41
43
44
+
impl jacquard_common::IntoStatic for GetPopularFeedGeneratorsOutput<'_> {
45
+
type Output = GetPopularFeedGeneratorsOutput<'static>;
46
+
fn into_static(self) -> Self::Output {
47
+
GetPopularFeedGeneratorsOutput {
48
+
cursor: self.cursor.into_static(),
49
+
feeds: self.feeds.into_static(),
50
+
extra_data: self.extra_data.into_static(),
51
+
}
52
+
}
53
+
}
54
+
42
55
impl jacquard_common::types::xrpc::XrpcRequest for GetPopularFeedGenerators<'_> {
43
56
const NSID: &'static str = "app.bsky.unspecced.getPopularFeedGenerators";
44
57
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
45
58
const OUTPUT_ENCODING: &'static str = "application/json";
46
59
type Output<'de> = GetPopularFeedGeneratorsOutput<'de>;
47
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
60
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
48
61
}
+45
-7
crates/jacquard-api/src/app_bsky/unspecced/get_post_thread_other_v2.rs
+45
-7
crates/jacquard-api/src/app_bsky/unspecced/get_post_thread_other_v2.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetPostThreadOtherV2<'a> {
11
11
#[serde(borrow)]
12
12
pub anchor: jacquard_common::types::string::AtUri<'a>,
13
+
///(default: false)
13
14
#[serde(skip_serializing_if = "std::option::Option::is_none")]
14
15
pub prioritize_followed_users: std::option::Option<bool>,
15
16
}
16
17
17
-
impl Default for GetPostThreadOtherV2<'_> {
18
-
fn default() -> Self {
19
-
Self {
20
-
anchor: Default::default(),
21
-
prioritize_followed_users: Some(false),
18
+
impl jacquard_common::IntoStatic for GetPostThreadOtherV2<'_> {
19
+
type Output = GetPostThreadOtherV2<'static>;
20
+
fn into_static(self) -> Self::Output {
21
+
GetPostThreadOtherV2 {
22
+
anchor: self.anchor.into_static(),
23
+
prioritize_followed_users: self.prioritize_followed_users.into_static(),
22
24
}
23
25
}
24
26
}
···
32
34
pub thread: Vec<jacquard_common::types::value::Data<'a>>,
33
35
}
34
36
37
+
impl jacquard_common::IntoStatic for GetPostThreadOtherV2Output<'_> {
38
+
type Output = GetPostThreadOtherV2Output<'static>;
39
+
fn into_static(self) -> Self::Output {
40
+
GetPostThreadOtherV2Output {
41
+
thread: self.thread.into_static(),
42
+
extra_data: self.extra_data.into_static(),
43
+
}
44
+
}
45
+
}
46
+
35
47
impl jacquard_common::types::xrpc::XrpcRequest for GetPostThreadOtherV2<'_> {
36
48
const NSID: &'static str = "app.bsky.unspecced.getPostThreadOtherV2";
37
49
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
38
50
const OUTPUT_ENCODING: &'static str = "application/json";
39
51
type Output<'de> = GetPostThreadOtherV2Output<'de>;
40
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
52
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
41
53
}
42
54
43
55
#[jacquard_derive::lexicon]
···
59
71
pub enum ThreadItemRecordValue<'a> {
60
72
#[serde(rename = "app.bsky.unspecced.defs#threadItemPost")]
61
73
DefsThreadItemPost(Box<crate::app_bsky::unspecced::ThreadItemPost<'a>>),
74
+
}
75
+
76
+
impl jacquard_common::IntoStatic for ThreadItemRecordValue<'_> {
77
+
type Output = ThreadItemRecordValue<'static>;
78
+
fn into_static(self) -> Self::Output {
79
+
match self {
80
+
ThreadItemRecordValue::DefsThreadItemPost(v) => {
81
+
ThreadItemRecordValue::DefsThreadItemPost(v.into_static())
82
+
}
83
+
ThreadItemRecordValue::Unknown(v) => {
84
+
ThreadItemRecordValue::Unknown(v.into_static())
85
+
}
86
+
}
87
+
}
88
+
}
89
+
90
+
impl jacquard_common::IntoStatic for ThreadItem<'_> {
91
+
type Output = ThreadItem<'static>;
92
+
fn into_static(self) -> Self::Output {
93
+
ThreadItem {
94
+
depth: self.depth.into_static(),
95
+
uri: self.uri.into_static(),
96
+
value: self.value.into_static(),
97
+
extra_data: self.extra_data.into_static(),
98
+
}
99
+
}
62
100
}
+64
-11
crates/jacquard-api/src/app_bsky/unspecced/get_post_thread_v2.rs
+64
-11
crates/jacquard-api/src/app_bsky/unspecced/get_post_thread_v2.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetPostThreadV2<'a> {
11
+
///(default: true)
11
12
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
13
pub above: std::option::Option<bool>,
13
14
#[serde(borrow)]
14
15
pub anchor: jacquard_common::types::string::AtUri<'a>,
16
+
///(default: 6, min: 0, max: 20)
15
17
#[serde(skip_serializing_if = "std::option::Option::is_none")]
16
18
pub below: std::option::Option<i64>,
19
+
///(default: 10, min: 0, max: 100)
17
20
#[serde(skip_serializing_if = "std::option::Option::is_none")]
18
21
pub branching_factor: std::option::Option<i64>,
22
+
///(default: false)
19
23
#[serde(skip_serializing_if = "std::option::Option::is_none")]
20
24
pub prioritize_followed_users: std::option::Option<bool>,
25
+
///(default: "oldest")
21
26
#[serde(skip_serializing_if = "std::option::Option::is_none")]
22
27
#[serde(borrow)]
23
28
pub sort: std::option::Option<jacquard_common::CowStr<'a>>,
24
29
}
25
30
26
-
impl Default for GetPostThreadV2<'_> {
27
-
fn default() -> Self {
28
-
Self {
29
-
above: Some(true),
30
-
anchor: Default::default(),
31
-
below: Some(6i64),
32
-
branching_factor: Some(10i64),
33
-
prioritize_followed_users: Some(false),
34
-
sort: Some(jacquard_common::CowStr::from("oldest")),
31
+
impl jacquard_common::IntoStatic for GetPostThreadV2<'_> {
32
+
type Output = GetPostThreadV2<'static>;
33
+
fn into_static(self) -> Self::Output {
34
+
GetPostThreadV2 {
35
+
above: self.above.into_static(),
36
+
anchor: self.anchor.into_static(),
37
+
below: self.below.into_static(),
38
+
branching_factor: self.branching_factor.into_static(),
39
+
prioritize_followed_users: self.prioritize_followed_users.into_static(),
40
+
sort: self.sort.into_static(),
35
41
}
36
42
}
37
43
}
···
48
54
#[serde(skip_serializing_if = "std::option::Option::is_none")]
49
55
#[serde(borrow)]
50
56
pub threadgate: std::option::Option<crate::app_bsky::feed::ThreadgateView<'a>>,
57
+
}
58
+
59
+
impl jacquard_common::IntoStatic for GetPostThreadV2Output<'_> {
60
+
type Output = GetPostThreadV2Output<'static>;
61
+
fn into_static(self) -> Self::Output {
62
+
GetPostThreadV2Output {
63
+
has_other_replies: self.has_other_replies.into_static(),
64
+
thread: self.thread.into_static(),
65
+
threadgate: self.threadgate.into_static(),
66
+
extra_data: self.extra_data.into_static(),
67
+
}
68
+
}
51
69
}
52
70
53
71
impl jacquard_common::types::xrpc::XrpcRequest for GetPostThreadV2<'_> {
···
55
73
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
56
74
const OUTPUT_ENCODING: &'static str = "application/json";
57
75
type Output<'de> = GetPostThreadV2Output<'de>;
58
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
76
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
59
77
}
60
78
61
79
#[jacquard_derive::lexicon]
···
85
103
DefsThreadItemNotFound(Box<crate::app_bsky::unspecced::ThreadItemNotFound<'a>>),
86
104
#[serde(rename = "app.bsky.unspecced.defs#threadItemBlocked")]
87
105
DefsThreadItemBlocked(Box<crate::app_bsky::unspecced::ThreadItemBlocked<'a>>),
106
+
}
107
+
108
+
impl jacquard_common::IntoStatic for ThreadItemRecordValue<'_> {
109
+
type Output = ThreadItemRecordValue<'static>;
110
+
fn into_static(self) -> Self::Output {
111
+
match self {
112
+
ThreadItemRecordValue::DefsThreadItemPost(v) => {
113
+
ThreadItemRecordValue::DefsThreadItemPost(v.into_static())
114
+
}
115
+
ThreadItemRecordValue::DefsThreadItemNoUnauthenticated(v) => {
116
+
ThreadItemRecordValue::DefsThreadItemNoUnauthenticated(v.into_static())
117
+
}
118
+
ThreadItemRecordValue::DefsThreadItemNotFound(v) => {
119
+
ThreadItemRecordValue::DefsThreadItemNotFound(v.into_static())
120
+
}
121
+
ThreadItemRecordValue::DefsThreadItemBlocked(v) => {
122
+
ThreadItemRecordValue::DefsThreadItemBlocked(v.into_static())
123
+
}
124
+
ThreadItemRecordValue::Unknown(v) => {
125
+
ThreadItemRecordValue::Unknown(v.into_static())
126
+
}
127
+
}
128
+
}
129
+
}
130
+
131
+
impl jacquard_common::IntoStatic for ThreadItem<'_> {
132
+
type Output = ThreadItem<'static>;
133
+
fn into_static(self) -> Self::Output {
134
+
ThreadItem {
135
+
depth: self.depth.into_static(),
136
+
uri: self.uri.into_static(),
137
+
value: self.value.into_static(),
138
+
extra_data: self.extra_data.into_static(),
139
+
}
140
+
}
88
141
}
+20
-2
crates/jacquard-api/src/app_bsky/unspecced/get_suggested_feeds.rs
+20
-2
crates/jacquard-api/src/app_bsky/unspecced/get_suggested_feeds.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetSuggestedFeeds {
11
+
///(default: 10, min: 1, max: 25)
11
12
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
13
pub limit: std::option::Option<i64>,
13
14
}
14
15
16
+
impl jacquard_common::IntoStatic for GetSuggestedFeeds {
17
+
type Output = GetSuggestedFeeds;
18
+
fn into_static(self) -> Self::Output {
19
+
self
20
+
}
21
+
}
22
+
15
23
#[jacquard_derive::lexicon]
16
24
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
25
#[serde(rename_all = "camelCase")]
···
20
28
pub feeds: Vec<crate::app_bsky::feed::GeneratorView<'a>>,
21
29
}
22
30
31
+
impl jacquard_common::IntoStatic for GetSuggestedFeedsOutput<'_> {
32
+
type Output = GetSuggestedFeedsOutput<'static>;
33
+
fn into_static(self) -> Self::Output {
34
+
GetSuggestedFeedsOutput {
35
+
feeds: self.feeds.into_static(),
36
+
extra_data: self.extra_data.into_static(),
37
+
}
38
+
}
39
+
}
40
+
23
41
impl jacquard_common::types::xrpc::XrpcRequest for GetSuggestedFeeds {
24
42
const NSID: &'static str = "app.bsky.unspecced.getSuggestedFeeds";
25
43
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
26
44
const OUTPUT_ENCODING: &'static str = "application/json";
27
45
type Output<'de> = GetSuggestedFeedsOutput<'de>;
28
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
46
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
29
47
}
+19
-7
crates/jacquard-api/src/app_bsky/unspecced/get_suggested_feeds_skeleton.rs
+19
-7
crates/jacquard-api/src/app_bsky/unspecced/get_suggested_feeds_skeleton.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetSuggestedFeedsSkeleton<'a> {
11
+
///(default: 10, min: 1, max: 25)
11
12
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
13
pub limit: std::option::Option<i64>,
13
14
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
15
16
pub viewer: std::option::Option<jacquard_common::types::string::Did<'a>>,
16
17
}
17
18
18
-
impl Default for GetSuggestedFeedsSkeleton<'_> {
19
-
fn default() -> Self {
20
-
Self {
21
-
limit: Some(10i64),
22
-
viewer: Default::default(),
19
+
impl jacquard_common::IntoStatic for GetSuggestedFeedsSkeleton<'_> {
20
+
type Output = GetSuggestedFeedsSkeleton<'static>;
21
+
fn into_static(self) -> Self::Output {
22
+
GetSuggestedFeedsSkeleton {
23
+
limit: self.limit.into_static(),
24
+
viewer: self.viewer.into_static(),
23
25
}
24
26
}
25
27
}
···
32
34
pub feeds: Vec<jacquard_common::types::string::AtUri<'a>>,
33
35
}
34
36
37
+
impl jacquard_common::IntoStatic for GetSuggestedFeedsSkeletonOutput<'_> {
38
+
type Output = GetSuggestedFeedsSkeletonOutput<'static>;
39
+
fn into_static(self) -> Self::Output {
40
+
GetSuggestedFeedsSkeletonOutput {
41
+
feeds: self.feeds.into_static(),
42
+
extra_data: self.extra_data.into_static(),
43
+
}
44
+
}
45
+
}
46
+
35
47
impl jacquard_common::types::xrpc::XrpcRequest for GetSuggestedFeedsSkeleton<'_> {
36
48
const NSID: &'static str = "app.bsky.unspecced.getSuggestedFeedsSkeleton";
37
49
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
38
50
const OUTPUT_ENCODING: &'static str = "application/json";
39
51
type Output<'de> = GetSuggestedFeedsSkeletonOutput<'de>;
40
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
52
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
41
53
}
+20
-2
crates/jacquard-api/src/app_bsky/unspecced/get_suggested_starter_packs.rs
+20
-2
crates/jacquard-api/src/app_bsky/unspecced/get_suggested_starter_packs.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetSuggestedStarterPacks {
11
+
///(default: 10, min: 1, max: 25)
11
12
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
13
pub limit: std::option::Option<i64>,
13
14
}
14
15
16
+
impl jacquard_common::IntoStatic for GetSuggestedStarterPacks {
17
+
type Output = GetSuggestedStarterPacks;
18
+
fn into_static(self) -> Self::Output {
19
+
self
20
+
}
21
+
}
22
+
15
23
#[jacquard_derive::lexicon]
16
24
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
25
#[serde(rename_all = "camelCase")]
···
20
28
pub starter_packs: Vec<crate::app_bsky::graph::StarterPackView<'a>>,
21
29
}
22
30
31
+
impl jacquard_common::IntoStatic for GetSuggestedStarterPacksOutput<'_> {
32
+
type Output = GetSuggestedStarterPacksOutput<'static>;
33
+
fn into_static(self) -> Self::Output {
34
+
GetSuggestedStarterPacksOutput {
35
+
starter_packs: self.starter_packs.into_static(),
36
+
extra_data: self.extra_data.into_static(),
37
+
}
38
+
}
39
+
}
40
+
23
41
impl jacquard_common::types::xrpc::XrpcRequest for GetSuggestedStarterPacks {
24
42
const NSID: &'static str = "app.bsky.unspecced.getSuggestedStarterPacks";
25
43
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
26
44
const OUTPUT_ENCODING: &'static str = "application/json";
27
45
type Output<'de> = GetSuggestedStarterPacksOutput<'de>;
28
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
46
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
29
47
}
+19
-7
crates/jacquard-api/src/app_bsky/unspecced/get_suggested_starter_packs_skeleton.rs
+19
-7
crates/jacquard-api/src/app_bsky/unspecced/get_suggested_starter_packs_skeleton.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetSuggestedStarterPacksSkeleton<'a> {
11
+
///(default: 10, min: 1, max: 25)
11
12
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
13
pub limit: std::option::Option<i64>,
13
14
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
15
16
pub viewer: std::option::Option<jacquard_common::types::string::Did<'a>>,
16
17
}
17
18
18
-
impl Default for GetSuggestedStarterPacksSkeleton<'_> {
19
-
fn default() -> Self {
20
-
Self {
21
-
limit: Some(10i64),
22
-
viewer: Default::default(),
19
+
impl jacquard_common::IntoStatic for GetSuggestedStarterPacksSkeleton<'_> {
20
+
type Output = GetSuggestedStarterPacksSkeleton<'static>;
21
+
fn into_static(self) -> Self::Output {
22
+
GetSuggestedStarterPacksSkeleton {
23
+
limit: self.limit.into_static(),
24
+
viewer: self.viewer.into_static(),
23
25
}
24
26
}
25
27
}
···
32
34
pub starter_packs: Vec<jacquard_common::types::string::AtUri<'a>>,
33
35
}
34
36
37
+
impl jacquard_common::IntoStatic for GetSuggestedStarterPacksSkeletonOutput<'_> {
38
+
type Output = GetSuggestedStarterPacksSkeletonOutput<'static>;
39
+
fn into_static(self) -> Self::Output {
40
+
GetSuggestedStarterPacksSkeletonOutput {
41
+
starter_packs: self.starter_packs.into_static(),
42
+
extra_data: self.extra_data.into_static(),
43
+
}
44
+
}
45
+
}
46
+
35
47
impl jacquard_common::types::xrpc::XrpcRequest for GetSuggestedStarterPacksSkeleton<'_> {
36
48
const NSID: &'static str = "app.bsky.unspecced.getSuggestedStarterPacksSkeleton";
37
49
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
38
50
const OUTPUT_ENCODING: &'static str = "application/json";
39
51
type Output<'de> = GetSuggestedStarterPacksSkeletonOutput<'de>;
40
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
52
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
41
53
}
+19
-7
crates/jacquard-api/src/app_bsky/unspecced/get_suggested_users.rs
+19
-7
crates/jacquard-api/src/app_bsky/unspecced/get_suggested_users.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetSuggestedUsers<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
12
#[serde(borrow)]
13
13
pub category: std::option::Option<jacquard_common::CowStr<'a>>,
14
+
///(default: 25, min: 1, max: 50)
14
15
#[serde(skip_serializing_if = "std::option::Option::is_none")]
15
16
pub limit: std::option::Option<i64>,
16
17
}
17
18
18
-
impl Default for GetSuggestedUsers<'_> {
19
-
fn default() -> Self {
20
-
Self {
21
-
category: Default::default(),
22
-
limit: Some(25i64),
19
+
impl jacquard_common::IntoStatic for GetSuggestedUsers<'_> {
20
+
type Output = GetSuggestedUsers<'static>;
21
+
fn into_static(self) -> Self::Output {
22
+
GetSuggestedUsers {
23
+
category: self.category.into_static(),
24
+
limit: self.limit.into_static(),
23
25
}
24
26
}
25
27
}
···
32
34
pub actors: Vec<crate::app_bsky::actor::ProfileView<'a>>,
33
35
}
34
36
37
+
impl jacquard_common::IntoStatic for GetSuggestedUsersOutput<'_> {
38
+
type Output = GetSuggestedUsersOutput<'static>;
39
+
fn into_static(self) -> Self::Output {
40
+
GetSuggestedUsersOutput {
41
+
actors: self.actors.into_static(),
42
+
extra_data: self.extra_data.into_static(),
43
+
}
44
+
}
45
+
}
46
+
35
47
impl jacquard_common::types::xrpc::XrpcRequest for GetSuggestedUsers<'_> {
36
48
const NSID: &'static str = "app.bsky.unspecced.getSuggestedUsers";
37
49
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
38
50
const OUTPUT_ENCODING: &'static str = "application/json";
39
51
type Output<'de> = GetSuggestedUsersOutput<'de>;
40
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
52
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
41
53
}
+20
-8
crates/jacquard-api/src/app_bsky/unspecced/get_suggested_users_skeleton.rs
+20
-8
crates/jacquard-api/src/app_bsky/unspecced/get_suggested_users_skeleton.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetSuggestedUsersSkeleton<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
12
#[serde(borrow)]
13
13
pub category: std::option::Option<jacquard_common::CowStr<'a>>,
14
+
///(default: 25, min: 1, max: 50)
14
15
#[serde(skip_serializing_if = "std::option::Option::is_none")]
15
16
pub limit: std::option::Option<i64>,
16
17
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
18
19
pub viewer: std::option::Option<jacquard_common::types::string::Did<'a>>,
19
20
}
20
21
21
-
impl Default for GetSuggestedUsersSkeleton<'_> {
22
-
fn default() -> Self {
23
-
Self {
24
-
category: Default::default(),
25
-
limit: Some(25i64),
26
-
viewer: Default::default(),
22
+
impl jacquard_common::IntoStatic for GetSuggestedUsersSkeleton<'_> {
23
+
type Output = GetSuggestedUsersSkeleton<'static>;
24
+
fn into_static(self) -> Self::Output {
25
+
GetSuggestedUsersSkeleton {
26
+
category: self.category.into_static(),
27
+
limit: self.limit.into_static(),
28
+
viewer: self.viewer.into_static(),
27
29
}
28
30
}
29
31
}
···
36
38
pub dids: Vec<jacquard_common::types::string::Did<'a>>,
37
39
}
38
40
41
+
impl jacquard_common::IntoStatic for GetSuggestedUsersSkeletonOutput<'_> {
42
+
type Output = GetSuggestedUsersSkeletonOutput<'static>;
43
+
fn into_static(self) -> Self::Output {
44
+
GetSuggestedUsersSkeletonOutput {
45
+
dids: self.dids.into_static(),
46
+
extra_data: self.extra_data.into_static(),
47
+
}
48
+
}
49
+
}
50
+
39
51
impl jacquard_common::types::xrpc::XrpcRequest for GetSuggestedUsersSkeleton<'_> {
40
52
const NSID: &'static str = "app.bsky.unspecced.getSuggestedUsersSkeleton";
41
53
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
42
54
const OUTPUT_ENCODING: &'static str = "application/json";
43
55
type Output<'de> = GetSuggestedUsersSkeletonOutput<'de>;
44
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
56
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
45
57
}
+24
-9
crates/jacquard-api/src/app_bsky/unspecced/get_suggestions_skeleton.rs
+24
-9
crates/jacquard-api/src/app_bsky/unspecced/get_suggestions_skeleton.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetSuggestionsSkeleton<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
12
#[serde(borrow)]
13
13
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
14
+
///(default: 50, min: 1, max: 100)
14
15
#[serde(skip_serializing_if = "std::option::Option::is_none")]
15
16
pub limit: std::option::Option<i64>,
16
17
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
21
22
pub viewer: std::option::Option<jacquard_common::types::string::Did<'a>>,
22
23
}
23
24
24
-
impl Default for GetSuggestionsSkeleton<'_> {
25
-
fn default() -> Self {
26
-
Self {
27
-
cursor: Default::default(),
28
-
limit: Some(50i64),
29
-
relative_to_did: Default::default(),
30
-
viewer: Default::default(),
25
+
impl jacquard_common::IntoStatic for GetSuggestionsSkeleton<'_> {
26
+
type Output = GetSuggestionsSkeleton<'static>;
27
+
fn into_static(self) -> Self::Output {
28
+
GetSuggestionsSkeleton {
29
+
cursor: self.cursor.into_static(),
30
+
limit: self.limit.into_static(),
31
+
relative_to_did: self.relative_to_did.into_static(),
32
+
viewer: self.viewer.into_static(),
31
33
}
32
34
}
33
35
}
···
50
52
pub relative_to_did: std::option::Option<jacquard_common::types::string::Did<'a>>,
51
53
}
52
54
55
+
impl jacquard_common::IntoStatic for GetSuggestionsSkeletonOutput<'_> {
56
+
type Output = GetSuggestionsSkeletonOutput<'static>;
57
+
fn into_static(self) -> Self::Output {
58
+
GetSuggestionsSkeletonOutput {
59
+
actors: self.actors.into_static(),
60
+
cursor: self.cursor.into_static(),
61
+
rec_id: self.rec_id.into_static(),
62
+
relative_to_did: self.relative_to_did.into_static(),
63
+
extra_data: self.extra_data.into_static(),
64
+
}
65
+
}
66
+
}
67
+
53
68
impl jacquard_common::types::xrpc::XrpcRequest for GetSuggestionsSkeleton<'_> {
54
69
const NSID: &'static str = "app.bsky.unspecced.getSuggestionsSkeleton";
55
70
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
56
71
const OUTPUT_ENCODING: &'static str = "application/json";
57
72
type Output<'de> = GetSuggestionsSkeletonOutput<'de>;
58
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
73
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
59
74
}
+30
-1
crates/jacquard-api/src/app_bsky/unspecced/get_tagged_suggestions.rs
+30
-1
crates/jacquard-api/src/app_bsky/unspecced/get_tagged_suggestions.rs
···
8
8
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetTaggedSuggestions {}
11
+
impl jacquard_common::IntoStatic for GetTaggedSuggestions {
12
+
type Output = GetTaggedSuggestions;
13
+
fn into_static(self) -> Self::Output {
14
+
self
15
+
}
16
+
}
17
+
11
18
#[jacquard_derive::lexicon]
12
19
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
13
20
#[serde(rename_all = "camelCase")]
···
16
23
pub suggestions: Vec<jacquard_common::types::value::Data<'a>>,
17
24
}
18
25
26
+
impl jacquard_common::IntoStatic for GetTaggedSuggestionsOutput<'_> {
27
+
type Output = GetTaggedSuggestionsOutput<'static>;
28
+
fn into_static(self) -> Self::Output {
29
+
GetTaggedSuggestionsOutput {
30
+
suggestions: self.suggestions.into_static(),
31
+
extra_data: self.extra_data.into_static(),
32
+
}
33
+
}
34
+
}
35
+
19
36
impl jacquard_common::types::xrpc::XrpcRequest for GetTaggedSuggestions {
20
37
const NSID: &'static str = "app.bsky.unspecced.getTaggedSuggestions";
21
38
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
22
39
const OUTPUT_ENCODING: &'static str = "application/json";
23
40
type Output<'de> = GetTaggedSuggestionsOutput<'de>;
24
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
41
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
25
42
}
26
43
27
44
#[jacquard_derive::lexicon]
···
34
51
pub subject_type: jacquard_common::CowStr<'a>,
35
52
#[serde(borrow)]
36
53
pub tag: jacquard_common::CowStr<'a>,
54
+
}
55
+
56
+
impl jacquard_common::IntoStatic for Suggestion<'_> {
57
+
type Output = Suggestion<'static>;
58
+
fn into_static(self) -> Self::Output {
59
+
Suggestion {
60
+
subject: self.subject.into_static(),
61
+
subject_type: self.subject_type.into_static(),
62
+
tag: self.tag.into_static(),
63
+
extra_data: self.extra_data.into_static(),
64
+
}
65
+
}
37
66
}
+20
-7
crates/jacquard-api/src/app_bsky/unspecced/get_trending_topics.rs
+20
-7
crates/jacquard-api/src/app_bsky/unspecced/get_trending_topics.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetTrendingTopics<'a> {
11
+
///(default: 10, min: 1, max: 25)
11
12
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
13
pub limit: std::option::Option<i64>,
13
14
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
15
16
pub viewer: std::option::Option<jacquard_common::types::string::Did<'a>>,
16
17
}
17
18
18
-
impl Default for GetTrendingTopics<'_> {
19
-
fn default() -> Self {
20
-
Self {
21
-
limit: Some(10i64),
22
-
viewer: Default::default(),
19
+
impl jacquard_common::IntoStatic for GetTrendingTopics<'_> {
20
+
type Output = GetTrendingTopics<'static>;
21
+
fn into_static(self) -> Self::Output {
22
+
GetTrendingTopics {
23
+
limit: self.limit.into_static(),
24
+
viewer: self.viewer.into_static(),
23
25
}
24
26
}
25
27
}
···
34
36
pub topics: Vec<crate::app_bsky::unspecced::TrendingTopic<'a>>,
35
37
}
36
38
39
+
impl jacquard_common::IntoStatic for GetTrendingTopicsOutput<'_> {
40
+
type Output = GetTrendingTopicsOutput<'static>;
41
+
fn into_static(self) -> Self::Output {
42
+
GetTrendingTopicsOutput {
43
+
suggested: self.suggested.into_static(),
44
+
topics: self.topics.into_static(),
45
+
extra_data: self.extra_data.into_static(),
46
+
}
47
+
}
48
+
}
49
+
37
50
impl jacquard_common::types::xrpc::XrpcRequest for GetTrendingTopics<'_> {
38
51
const NSID: &'static str = "app.bsky.unspecced.getTrendingTopics";
39
52
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
40
53
const OUTPUT_ENCODING: &'static str = "application/json";
41
54
type Output<'de> = GetTrendingTopicsOutput<'de>;
42
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
55
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
43
56
}
+20
-2
crates/jacquard-api/src/app_bsky/unspecced/get_trends.rs
+20
-2
crates/jacquard-api/src/app_bsky/unspecced/get_trends.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetTrends {
11
+
///(default: 10, min: 1, max: 25)
11
12
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
13
pub limit: std::option::Option<i64>,
13
14
}
14
15
16
+
impl jacquard_common::IntoStatic for GetTrends {
17
+
type Output = GetTrends;
18
+
fn into_static(self) -> Self::Output {
19
+
self
20
+
}
21
+
}
22
+
15
23
#[jacquard_derive::lexicon]
16
24
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
25
#[serde(rename_all = "camelCase")]
···
20
28
pub trends: Vec<crate::app_bsky::unspecced::TrendView<'a>>,
21
29
}
22
30
31
+
impl jacquard_common::IntoStatic for GetTrendsOutput<'_> {
32
+
type Output = GetTrendsOutput<'static>;
33
+
fn into_static(self) -> Self::Output {
34
+
GetTrendsOutput {
35
+
trends: self.trends.into_static(),
36
+
extra_data: self.extra_data.into_static(),
37
+
}
38
+
}
39
+
}
40
+
23
41
impl jacquard_common::types::xrpc::XrpcRequest for GetTrends {
24
42
const NSID: &'static str = "app.bsky.unspecced.getTrends";
25
43
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
26
44
const OUTPUT_ENCODING: &'static str = "application/json";
27
45
type Output<'de> = GetTrendsOutput<'de>;
28
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
46
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
29
47
}
+19
-7
crates/jacquard-api/src/app_bsky/unspecced/get_trends_skeleton.rs
+19
-7
crates/jacquard-api/src/app_bsky/unspecced/get_trends_skeleton.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetTrendsSkeleton<'a> {
11
+
///(default: 10, min: 1, max: 25)
11
12
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
13
pub limit: std::option::Option<i64>,
13
14
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
15
16
pub viewer: std::option::Option<jacquard_common::types::string::Did<'a>>,
16
17
}
17
18
18
-
impl Default for GetTrendsSkeleton<'_> {
19
-
fn default() -> Self {
20
-
Self {
21
-
limit: Some(10i64),
22
-
viewer: Default::default(),
19
+
impl jacquard_common::IntoStatic for GetTrendsSkeleton<'_> {
20
+
type Output = GetTrendsSkeleton<'static>;
21
+
fn into_static(self) -> Self::Output {
22
+
GetTrendsSkeleton {
23
+
limit: self.limit.into_static(),
24
+
viewer: self.viewer.into_static(),
23
25
}
24
26
}
25
27
}
···
32
34
pub trends: Vec<crate::app_bsky::unspecced::SkeletonTrend<'a>>,
33
35
}
34
36
37
+
impl jacquard_common::IntoStatic for GetTrendsSkeletonOutput<'_> {
38
+
type Output = GetTrendsSkeletonOutput<'static>;
39
+
fn into_static(self) -> Self::Output {
40
+
GetTrendsSkeletonOutput {
41
+
trends: self.trends.into_static(),
42
+
extra_data: self.extra_data.into_static(),
43
+
}
44
+
}
45
+
}
46
+
35
47
impl jacquard_common::types::xrpc::XrpcRequest for GetTrendsSkeleton<'_> {
36
48
const NSID: &'static str = "app.bsky.unspecced.getTrendsSkeleton";
37
49
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
38
50
const OUTPUT_ENCODING: &'static str = "application/json";
39
51
type Output<'de> = GetTrendsSkeletonOutput<'de>;
40
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
52
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
41
53
}
+42
crates/jacquard-api/src/app_bsky/unspecced/init_age_assurance.rs
+42
crates/jacquard-api/src/app_bsky/unspecced/init_age_assurance.rs
···
20
20
pub language: jacquard_common::CowStr<'a>,
21
21
}
22
22
23
+
impl jacquard_common::IntoStatic for InitAgeAssurance<'_> {
24
+
type Output = InitAgeAssurance<'static>;
25
+
fn into_static(self) -> Self::Output {
26
+
InitAgeAssurance {
27
+
country_code: self.country_code.into_static(),
28
+
email: self.email.into_static(),
29
+
language: self.language.into_static(),
30
+
extra_data: self.extra_data.into_static(),
31
+
}
32
+
}
33
+
}
34
+
23
35
#[jacquard_derive::lexicon]
24
36
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
25
37
#[serde(rename_all = "camelCase")]
···
27
39
#[serde(flatten)]
28
40
#[serde(borrow)]
29
41
pub value: crate::app_bsky::unspecced::AgeAssuranceState<'a>,
42
+
}
43
+
44
+
impl jacquard_common::IntoStatic for InitAgeAssuranceOutput<'_> {
45
+
type Output = InitAgeAssuranceOutput<'static>;
46
+
fn into_static(self) -> Self::Output {
47
+
InitAgeAssuranceOutput {
48
+
value: self.value.into_static(),
49
+
extra_data: self.extra_data.into_static(),
50
+
}
51
+
}
30
52
}
31
53
32
54
#[jacquard_derive::open_union]
···
76
98
Ok(())
77
99
}
78
100
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
101
+
}
102
+
}
103
+
}
104
+
105
+
impl jacquard_common::IntoStatic for InitAgeAssuranceError<'_> {
106
+
type Output = InitAgeAssuranceError<'static>;
107
+
fn into_static(self) -> Self::Output {
108
+
match self {
109
+
InitAgeAssuranceError::InvalidEmail(v) => {
110
+
InitAgeAssuranceError::InvalidEmail(v.into_static())
111
+
}
112
+
InitAgeAssuranceError::DidTooLong(v) => {
113
+
InitAgeAssuranceError::DidTooLong(v.into_static())
114
+
}
115
+
InitAgeAssuranceError::InvalidInitiation(v) => {
116
+
InitAgeAssuranceError::InvalidInitiation(v.into_static())
117
+
}
118
+
InitAgeAssuranceError::Unknown(v) => {
119
+
InitAgeAssuranceError::Unknown(v.into_static())
120
+
}
79
121
}
80
122
}
81
123
}
+37
-9
crates/jacquard-api/src/app_bsky/unspecced/search_actors_skeleton.rs
+37
-9
crates/jacquard-api/src/app_bsky/unspecced/search_actors_skeleton.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct SearchActorsSkeleton<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
12
#[serde(borrow)]
13
13
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
14
+
///(default: 25, min: 1, max: 100)
14
15
#[serde(skip_serializing_if = "std::option::Option::is_none")]
15
16
pub limit: std::option::Option<i64>,
16
17
#[serde(borrow)]
···
22
23
pub viewer: std::option::Option<jacquard_common::types::string::Did<'a>>,
23
24
}
24
25
25
-
impl Default for SearchActorsSkeleton<'_> {
26
-
fn default() -> Self {
27
-
Self {
28
-
cursor: Default::default(),
29
-
limit: Some(25i64),
30
-
q: Default::default(),
31
-
typeahead: Default::default(),
32
-
viewer: Default::default(),
26
+
impl jacquard_common::IntoStatic for SearchActorsSkeleton<'_> {
27
+
type Output = SearchActorsSkeleton<'static>;
28
+
fn into_static(self) -> Self::Output {
29
+
SearchActorsSkeleton {
30
+
cursor: self.cursor.into_static(),
31
+
limit: self.limit.into_static(),
32
+
q: self.q.into_static(),
33
+
typeahead: self.typeahead.into_static(),
34
+
viewer: self.viewer.into_static(),
33
35
}
34
36
}
35
37
}
···
48
50
pub hits_total: std::option::Option<i64>,
49
51
}
50
52
53
+
impl jacquard_common::IntoStatic for SearchActorsSkeletonOutput<'_> {
54
+
type Output = SearchActorsSkeletonOutput<'static>;
55
+
fn into_static(self) -> Self::Output {
56
+
SearchActorsSkeletonOutput {
57
+
actors: self.actors.into_static(),
58
+
cursor: self.cursor.into_static(),
59
+
hits_total: self.hits_total.into_static(),
60
+
extra_data: self.extra_data.into_static(),
61
+
}
62
+
}
63
+
}
64
+
51
65
#[jacquard_derive::open_union]
52
66
#[derive(
53
67
serde::Serialize,
···
77
91
Ok(())
78
92
}
79
93
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
94
+
}
95
+
}
96
+
}
97
+
98
+
impl jacquard_common::IntoStatic for SearchActorsSkeletonError<'_> {
99
+
type Output = SearchActorsSkeletonError<'static>;
100
+
fn into_static(self) -> Self::Output {
101
+
match self {
102
+
SearchActorsSkeletonError::BadQueryString(v) => {
103
+
SearchActorsSkeletonError::BadQueryString(v.into_static())
104
+
}
105
+
SearchActorsSkeletonError::Unknown(v) => {
106
+
SearchActorsSkeletonError::Unknown(v.into_static())
107
+
}
80
108
}
81
109
}
82
110
}
+46
-17
crates/jacquard-api/src/app_bsky/unspecced/search_posts_skeleton.rs
+46
-17
crates/jacquard-api/src/app_bsky/unspecced/search_posts_skeleton.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct SearchPostsSkeleton<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
19
19
pub domain: std::option::Option<jacquard_common::CowStr<'a>>,
20
20
#[serde(skip_serializing_if = "std::option::Option::is_none")]
21
21
pub lang: std::option::Option<jacquard_common::types::string::Language>,
22
+
///(default: 25, min: 1, max: 100)
22
23
#[serde(skip_serializing_if = "std::option::Option::is_none")]
23
24
pub limit: std::option::Option<i64>,
24
25
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
29
30
#[serde(skip_serializing_if = "std::option::Option::is_none")]
30
31
#[serde(borrow)]
31
32
pub since: std::option::Option<jacquard_common::CowStr<'a>>,
33
+
///(default: "latest")
32
34
#[serde(skip_serializing_if = "std::option::Option::is_none")]
33
35
#[serde(borrow)]
34
36
pub sort: std::option::Option<jacquard_common::CowStr<'a>>,
···
46
48
pub viewer: std::option::Option<jacquard_common::types::string::Did<'a>>,
47
49
}
48
50
49
-
impl Default for SearchPostsSkeleton<'_> {
50
-
fn default() -> Self {
51
-
Self {
52
-
author: Default::default(),
53
-
cursor: Default::default(),
54
-
domain: Default::default(),
55
-
lang: Default::default(),
56
-
limit: Some(25i64),
57
-
mentions: Default::default(),
58
-
q: Default::default(),
59
-
since: Default::default(),
60
-
sort: Some(jacquard_common::CowStr::from("latest")),
61
-
tag: Default::default(),
62
-
until: Default::default(),
63
-
url: Default::default(),
64
-
viewer: Default::default(),
51
+
impl jacquard_common::IntoStatic for SearchPostsSkeleton<'_> {
52
+
type Output = SearchPostsSkeleton<'static>;
53
+
fn into_static(self) -> Self::Output {
54
+
SearchPostsSkeleton {
55
+
author: self.author.into_static(),
56
+
cursor: self.cursor.into_static(),
57
+
domain: self.domain.into_static(),
58
+
lang: self.lang.into_static(),
59
+
limit: self.limit.into_static(),
60
+
mentions: self.mentions.into_static(),
61
+
q: self.q.into_static(),
62
+
since: self.since.into_static(),
63
+
sort: self.sort.into_static(),
64
+
tag: self.tag.into_static(),
65
+
until: self.until.into_static(),
66
+
url: self.url.into_static(),
67
+
viewer: self.viewer.into_static(),
65
68
}
66
69
}
67
70
}
···
80
83
pub posts: Vec<crate::app_bsky::unspecced::SkeletonSearchPost<'a>>,
81
84
}
82
85
86
+
impl jacquard_common::IntoStatic for SearchPostsSkeletonOutput<'_> {
87
+
type Output = SearchPostsSkeletonOutput<'static>;
88
+
fn into_static(self) -> Self::Output {
89
+
SearchPostsSkeletonOutput {
90
+
cursor: self.cursor.into_static(),
91
+
hits_total: self.hits_total.into_static(),
92
+
posts: self.posts.into_static(),
93
+
extra_data: self.extra_data.into_static(),
94
+
}
95
+
}
96
+
}
97
+
83
98
#[jacquard_derive::open_union]
84
99
#[derive(
85
100
serde::Serialize,
···
109
124
Ok(())
110
125
}
111
126
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
127
+
}
128
+
}
129
+
}
130
+
131
+
impl jacquard_common::IntoStatic for SearchPostsSkeletonError<'_> {
132
+
type Output = SearchPostsSkeletonError<'static>;
133
+
fn into_static(self) -> Self::Output {
134
+
match self {
135
+
SearchPostsSkeletonError::BadQueryString(v) => {
136
+
SearchPostsSkeletonError::BadQueryString(v.into_static())
137
+
}
138
+
SearchPostsSkeletonError::Unknown(v) => {
139
+
SearchPostsSkeletonError::Unknown(v.into_static())
140
+
}
112
141
}
113
142
}
114
143
}
+36
-8
crates/jacquard-api/src/app_bsky/unspecced/search_starter_packs_skeleton.rs
+36
-8
crates/jacquard-api/src/app_bsky/unspecced/search_starter_packs_skeleton.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct SearchStarterPacksSkeleton<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
12
#[serde(borrow)]
13
13
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
14
+
///(default: 25, min: 1, max: 100)
14
15
#[serde(skip_serializing_if = "std::option::Option::is_none")]
15
16
pub limit: std::option::Option<i64>,
16
17
#[serde(borrow)]
···
20
21
pub viewer: std::option::Option<jacquard_common::types::string::Did<'a>>,
21
22
}
22
23
23
-
impl Default for SearchStarterPacksSkeleton<'_> {
24
-
fn default() -> Self {
25
-
Self {
26
-
cursor: Default::default(),
27
-
limit: Some(25i64),
28
-
q: Default::default(),
29
-
viewer: Default::default(),
24
+
impl jacquard_common::IntoStatic for SearchStarterPacksSkeleton<'_> {
25
+
type Output = SearchStarterPacksSkeleton<'static>;
26
+
fn into_static(self) -> Self::Output {
27
+
SearchStarterPacksSkeleton {
28
+
cursor: self.cursor.into_static(),
29
+
limit: self.limit.into_static(),
30
+
q: self.q.into_static(),
31
+
viewer: self.viewer.into_static(),
30
32
}
31
33
}
32
34
}
···
45
47
pub starter_packs: Vec<crate::app_bsky::unspecced::SkeletonSearchStarterPack<'a>>,
46
48
}
47
49
50
+
impl jacquard_common::IntoStatic for SearchStarterPacksSkeletonOutput<'_> {
51
+
type Output = SearchStarterPacksSkeletonOutput<'static>;
52
+
fn into_static(self) -> Self::Output {
53
+
SearchStarterPacksSkeletonOutput {
54
+
cursor: self.cursor.into_static(),
55
+
hits_total: self.hits_total.into_static(),
56
+
starter_packs: self.starter_packs.into_static(),
57
+
extra_data: self.extra_data.into_static(),
58
+
}
59
+
}
60
+
}
61
+
48
62
#[jacquard_derive::open_union]
49
63
#[derive(
50
64
serde::Serialize,
···
74
88
Ok(())
75
89
}
76
90
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
91
+
}
92
+
}
93
+
}
94
+
95
+
impl jacquard_common::IntoStatic for SearchStarterPacksSkeletonError<'_> {
96
+
type Output = SearchStarterPacksSkeletonError<'static>;
97
+
fn into_static(self) -> Self::Output {
98
+
match self {
99
+
SearchStarterPacksSkeletonError::BadQueryString(v) => {
100
+
SearchStarterPacksSkeletonError::BadQueryString(v.into_static())
101
+
}
102
+
SearchStarterPacksSkeletonError::Unknown(v) => {
103
+
SearchStarterPacksSkeletonError::Unknown(v.into_static())
104
+
}
77
105
}
78
106
}
79
107
}
+16
crates/jacquard-api/src/app_bsky/video.rs
+16
crates/jacquard-api/src/app_bsky/video.rs
···
32
32
///The state of the video processing job. All values not listed as a known value indicate that the job is in process.
33
33
#[serde(borrow)]
34
34
pub state: jacquard_common::CowStr<'a>,
35
+
}
36
+
37
+
impl jacquard_common::IntoStatic for JobStatus<'_> {
38
+
type Output = JobStatus<'static>;
39
+
fn into_static(self) -> Self::Output {
40
+
JobStatus {
41
+
blob: self.blob.into_static(),
42
+
did: self.did.into_static(),
43
+
error: self.error.into_static(),
44
+
job_id: self.job_id.into_static(),
45
+
message: self.message.into_static(),
46
+
progress: self.progress.into_static(),
47
+
state: self.state.into_static(),
48
+
extra_data: self.extra_data.into_static(),
49
+
}
50
+
}
35
51
}
+20
-1
crates/jacquard-api/src/app_bsky/video/get_job_status.rs
+20
-1
crates/jacquard-api/src/app_bsky/video/get_job_status.rs
···
12
12
pub job_id: jacquard_common::CowStr<'a>,
13
13
}
14
14
15
+
impl jacquard_common::IntoStatic for GetJobStatus<'_> {
16
+
type Output = GetJobStatus<'static>;
17
+
fn into_static(self) -> Self::Output {
18
+
GetJobStatus {
19
+
job_id: self.job_id.into_static(),
20
+
}
21
+
}
22
+
}
23
+
15
24
#[jacquard_derive::lexicon]
16
25
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
26
#[serde(rename_all = "camelCase")]
···
20
29
pub job_status: crate::app_bsky::video::JobStatus<'a>,
21
30
}
22
31
32
+
impl jacquard_common::IntoStatic for GetJobStatusOutput<'_> {
33
+
type Output = GetJobStatusOutput<'static>;
34
+
fn into_static(self) -> Self::Output {
35
+
GetJobStatusOutput {
36
+
job_status: self.job_status.into_static(),
37
+
extra_data: self.extra_data.into_static(),
38
+
}
39
+
}
40
+
}
41
+
23
42
impl jacquard_common::types::xrpc::XrpcRequest for GetJobStatus<'_> {
24
43
const NSID: &'static str = "app.bsky.video.getJobStatus";
25
44
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
26
45
const OUTPUT_ENCODING: &'static str = "application/json";
27
46
type Output<'de> = GetJobStatusOutput<'de>;
28
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
47
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
29
48
}
+15
-1
crates/jacquard-api/src/app_bsky/video/get_upload_limits.rs
+15
-1
crates/jacquard-api/src/app_bsky/video/get_upload_limits.rs
···
22
22
pub remaining_daily_videos: std::option::Option<i64>,
23
23
}
24
24
25
+
impl jacquard_common::IntoStatic for GetUploadLimitsOutput<'_> {
26
+
type Output = GetUploadLimitsOutput<'static>;
27
+
fn into_static(self) -> Self::Output {
28
+
GetUploadLimitsOutput {
29
+
can_upload: self.can_upload.into_static(),
30
+
error: self.error.into_static(),
31
+
message: self.message.into_static(),
32
+
remaining_daily_bytes: self.remaining_daily_bytes.into_static(),
33
+
remaining_daily_videos: self.remaining_daily_videos.into_static(),
34
+
extra_data: self.extra_data.into_static(),
35
+
}
36
+
}
37
+
}
38
+
25
39
/// XRPC request marker type
26
40
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]
27
41
pub struct GetUploadLimits;
···
30
44
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
31
45
const OUTPUT_ENCODING: &'static str = "application/json";
32
46
type Output<'de> = GetUploadLimitsOutput<'de>;
33
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
47
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
34
48
}
+20
-1
crates/jacquard-api/src/app_bsky/video/upload_video.rs
+20
-1
crates/jacquard-api/src/app_bsky/video/upload_video.rs
···
9
9
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
10
10
#[serde(rename_all = "camelCase")]
11
11
pub struct UploadVideo<'a> {}
12
+
impl jacquard_common::IntoStatic for UploadVideo<'_> {
13
+
type Output = UploadVideo<'static>;
14
+
fn into_static(self) -> Self::Output {
15
+
UploadVideo {
16
+
extra_data: self.extra_data.into_static(),
17
+
}
18
+
}
19
+
}
20
+
12
21
#[jacquard_derive::lexicon]
13
22
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
14
23
#[serde(rename_all = "camelCase")]
···
17
26
pub job_status: crate::app_bsky::video::JobStatus<'a>,
18
27
}
19
28
29
+
impl jacquard_common::IntoStatic for UploadVideoOutput<'_> {
30
+
type Output = UploadVideoOutput<'static>;
31
+
fn into_static(self) -> Self::Output {
32
+
UploadVideoOutput {
33
+
job_status: self.job_status.into_static(),
34
+
extra_data: self.extra_data.into_static(),
35
+
}
36
+
}
37
+
}
38
+
20
39
impl jacquard_common::types::xrpc::XrpcRequest for UploadVideo<'_> {
21
40
const NSID: &'static str = "app.bsky.video.uploadVideo";
22
41
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
24
43
);
25
44
const OUTPUT_ENCODING: &'static str = "application/json";
26
45
type Output<'de> = UploadVideoOutput<'de>;
27
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
46
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
28
47
}
+18
crates/jacquard-api/src/chat_bsky/actor.rs
+18
crates/jacquard-api/src/chat_bsky/actor.rs
···
38
38
#[serde(skip_serializing_if = "std::option::Option::is_none")]
39
39
#[serde(borrow)]
40
40
pub viewer: std::option::Option<crate::app_bsky::actor::ViewerState<'a>>,
41
+
}
42
+
43
+
impl jacquard_common::IntoStatic for ProfileViewBasic<'_> {
44
+
type Output = ProfileViewBasic<'static>;
45
+
fn into_static(self) -> Self::Output {
46
+
ProfileViewBasic {
47
+
associated: self.associated.into_static(),
48
+
avatar: self.avatar.into_static(),
49
+
chat_disabled: self.chat_disabled.into_static(),
50
+
did: self.did.into_static(),
51
+
display_name: self.display_name.into_static(),
52
+
handle: self.handle.into_static(),
53
+
labels: self.labels.into_static(),
54
+
verification: self.verification.into_static(),
55
+
viewer: self.viewer.into_static(),
56
+
extra_data: self.extra_data.into_static(),
57
+
}
58
+
}
41
59
}
+10
crates/jacquard-api/src/chat_bsky/actor/declaration.rs
+10
crates/jacquard-api/src/chat_bsky/actor/declaration.rs
···
16
16
17
17
impl jacquard_common::types::collection::Collection for Declaration<'_> {
18
18
const NSID: &'static str = "chat.bsky.actor.declaration";
19
+
}
20
+
21
+
impl jacquard_common::IntoStatic for Declaration<'_> {
22
+
type Output = Declaration<'static>;
23
+
fn into_static(self) -> Self::Output {
24
+
Declaration {
25
+
allow_incoming: self.allow_incoming.into_static(),
26
+
extra_data: self.extra_data.into_static(),
27
+
}
28
+
}
19
29
}
+10
-1
crates/jacquard-api/src/chat_bsky/actor/delete_account.rs
+10
-1
crates/jacquard-api/src/chat_bsky/actor/delete_account.rs
···
9
9
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
10
10
#[serde(rename_all = "camelCase")]
11
11
pub struct DeleteAccountOutput<'a> {}
12
+
impl jacquard_common::IntoStatic for DeleteAccountOutput<'_> {
13
+
type Output = DeleteAccountOutput<'static>;
14
+
fn into_static(self) -> Self::Output {
15
+
DeleteAccountOutput {
16
+
extra_data: self.extra_data.into_static(),
17
+
}
18
+
}
19
+
}
20
+
12
21
/// XRPC request marker type
13
22
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]
14
23
pub struct DeleteAccount;
···
19
28
);
20
29
const OUTPUT_ENCODING: &'static str = "application/json";
21
30
type Output<'de> = DeleteAccountOutput<'de>;
22
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
31
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
23
32
}
+10
-1
crates/jacquard-api/src/chat_bsky/actor/export_account_data.rs
+10
-1
crates/jacquard-api/src/chat_bsky/actor/export_account_data.rs
···
9
9
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
10
10
#[serde(rename_all = "camelCase")]
11
11
pub struct ExportAccountDataOutput<'a> {}
12
+
impl jacquard_common::IntoStatic for ExportAccountDataOutput<'_> {
13
+
type Output = ExportAccountDataOutput<'static>;
14
+
fn into_static(self) -> Self::Output {
15
+
ExportAccountDataOutput {
16
+
extra_data: self.extra_data.into_static(),
17
+
}
18
+
}
19
+
}
20
+
12
21
/// XRPC request marker type
13
22
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]
14
23
pub struct ExportAccountData;
···
17
26
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
18
27
const OUTPUT_ENCODING: &'static str = "application/jsonl";
19
28
type Output<'de> = ExportAccountDataOutput<'de>;
20
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
29
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
21
30
}
+336
crates/jacquard-api/src/chat_bsky/convo.rs
+336
crates/jacquard-api/src/chat_bsky/convo.rs
···
51
51
#[serde(tag = "$type")]
52
52
#[serde(bound(deserialize = "'de: 'a"))]
53
53
pub enum ConvoViewRecordLastMessage<'a> {}
54
+
impl jacquard_common::IntoStatic for ConvoViewRecordLastMessage<'_> {
55
+
type Output = ConvoViewRecordLastMessage<'static>;
56
+
fn into_static(self) -> Self::Output {
57
+
match self {
58
+
ConvoViewRecordLastMessage::Unknown(v) => {
59
+
ConvoViewRecordLastMessage::Unknown(v.into_static())
60
+
}
61
+
}
62
+
}
63
+
}
64
+
54
65
#[jacquard_derive::open_union]
55
66
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
56
67
#[serde(tag = "$type")]
57
68
#[serde(bound(deserialize = "'de: 'a"))]
58
69
pub enum ConvoViewRecordLastReaction<'a> {}
70
+
impl jacquard_common::IntoStatic for ConvoViewRecordLastReaction<'_> {
71
+
type Output = ConvoViewRecordLastReaction<'static>;
72
+
fn into_static(self) -> Self::Output {
73
+
match self {
74
+
ConvoViewRecordLastReaction::Unknown(v) => {
75
+
ConvoViewRecordLastReaction::Unknown(v.into_static())
76
+
}
77
+
}
78
+
}
79
+
}
80
+
81
+
impl jacquard_common::IntoStatic for ConvoView<'_> {
82
+
type Output = ConvoView<'static>;
83
+
fn into_static(self) -> Self::Output {
84
+
ConvoView {
85
+
id: self.id.into_static(),
86
+
last_message: self.last_message.into_static(),
87
+
last_reaction: self.last_reaction.into_static(),
88
+
members: self.members.into_static(),
89
+
muted: self.muted.into_static(),
90
+
rev: self.rev.into_static(),
91
+
status: self.status.into_static(),
92
+
unread_count: self.unread_count.into_static(),
93
+
extra_data: self.extra_data.into_static(),
94
+
}
95
+
}
96
+
}
97
+
59
98
#[jacquard_derive::lexicon]
60
99
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
61
100
#[serde(rename_all = "camelCase")]
···
69
108
pub sent_at: jacquard_common::types::string::Datetime,
70
109
}
71
110
111
+
impl jacquard_common::IntoStatic for DeletedMessageView<'_> {
112
+
type Output = DeletedMessageView<'static>;
113
+
fn into_static(self) -> Self::Output {
114
+
DeletedMessageView {
115
+
id: self.id.into_static(),
116
+
rev: self.rev.into_static(),
117
+
sender: self.sender.into_static(),
118
+
sent_at: self.sent_at.into_static(),
119
+
extra_data: self.extra_data.into_static(),
120
+
}
121
+
}
122
+
}
123
+
72
124
#[jacquard_derive::lexicon]
73
125
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
74
126
#[serde(rename_all = "camelCase")]
···
77
129
pub convo_id: jacquard_common::CowStr<'a>,
78
130
#[serde(borrow)]
79
131
pub rev: jacquard_common::CowStr<'a>,
132
+
}
133
+
134
+
impl jacquard_common::IntoStatic for LogAcceptConvo<'_> {
135
+
type Output = LogAcceptConvo<'static>;
136
+
fn into_static(self) -> Self::Output {
137
+
LogAcceptConvo {
138
+
convo_id: self.convo_id.into_static(),
139
+
rev: self.rev.into_static(),
140
+
extra_data: self.extra_data.into_static(),
141
+
}
142
+
}
80
143
}
81
144
82
145
#[jacquard_derive::lexicon]
···
98
161
#[serde(tag = "$type")]
99
162
#[serde(bound(deserialize = "'de: 'a"))]
100
163
pub enum LogAddReactionRecordMessage<'a> {}
164
+
impl jacquard_common::IntoStatic for LogAddReactionRecordMessage<'_> {
165
+
type Output = LogAddReactionRecordMessage<'static>;
166
+
fn into_static(self) -> Self::Output {
167
+
match self {
168
+
LogAddReactionRecordMessage::Unknown(v) => {
169
+
LogAddReactionRecordMessage::Unknown(v.into_static())
170
+
}
171
+
}
172
+
}
173
+
}
174
+
175
+
impl jacquard_common::IntoStatic for LogAddReaction<'_> {
176
+
type Output = LogAddReaction<'static>;
177
+
fn into_static(self) -> Self::Output {
178
+
LogAddReaction {
179
+
convo_id: self.convo_id.into_static(),
180
+
message: self.message.into_static(),
181
+
reaction: self.reaction.into_static(),
182
+
rev: self.rev.into_static(),
183
+
extra_data: self.extra_data.into_static(),
184
+
}
185
+
}
186
+
}
187
+
101
188
#[jacquard_derive::lexicon]
102
189
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
103
190
#[serde(rename_all = "camelCase")]
···
108
195
pub rev: jacquard_common::CowStr<'a>,
109
196
}
110
197
198
+
impl jacquard_common::IntoStatic for LogBeginConvo<'_> {
199
+
type Output = LogBeginConvo<'static>;
200
+
fn into_static(self) -> Self::Output {
201
+
LogBeginConvo {
202
+
convo_id: self.convo_id.into_static(),
203
+
rev: self.rev.into_static(),
204
+
extra_data: self.extra_data.into_static(),
205
+
}
206
+
}
207
+
}
208
+
111
209
#[jacquard_derive::lexicon]
112
210
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
113
211
#[serde(rename_all = "camelCase")]
···
125
223
#[serde(tag = "$type")]
126
224
#[serde(bound(deserialize = "'de: 'a"))]
127
225
pub enum LogCreateMessageRecordMessage<'a> {}
226
+
impl jacquard_common::IntoStatic for LogCreateMessageRecordMessage<'_> {
227
+
type Output = LogCreateMessageRecordMessage<'static>;
228
+
fn into_static(self) -> Self::Output {
229
+
match self {
230
+
LogCreateMessageRecordMessage::Unknown(v) => {
231
+
LogCreateMessageRecordMessage::Unknown(v.into_static())
232
+
}
233
+
}
234
+
}
235
+
}
236
+
237
+
impl jacquard_common::IntoStatic for LogCreateMessage<'_> {
238
+
type Output = LogCreateMessage<'static>;
239
+
fn into_static(self) -> Self::Output {
240
+
LogCreateMessage {
241
+
convo_id: self.convo_id.into_static(),
242
+
message: self.message.into_static(),
243
+
rev: self.rev.into_static(),
244
+
extra_data: self.extra_data.into_static(),
245
+
}
246
+
}
247
+
}
248
+
128
249
#[jacquard_derive::lexicon]
129
250
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
130
251
#[serde(rename_all = "camelCase")]
···
142
263
#[serde(tag = "$type")]
143
264
#[serde(bound(deserialize = "'de: 'a"))]
144
265
pub enum LogDeleteMessageRecordMessage<'a> {}
266
+
impl jacquard_common::IntoStatic for LogDeleteMessageRecordMessage<'_> {
267
+
type Output = LogDeleteMessageRecordMessage<'static>;
268
+
fn into_static(self) -> Self::Output {
269
+
match self {
270
+
LogDeleteMessageRecordMessage::Unknown(v) => {
271
+
LogDeleteMessageRecordMessage::Unknown(v.into_static())
272
+
}
273
+
}
274
+
}
275
+
}
276
+
277
+
impl jacquard_common::IntoStatic for LogDeleteMessage<'_> {
278
+
type Output = LogDeleteMessage<'static>;
279
+
fn into_static(self) -> Self::Output {
280
+
LogDeleteMessage {
281
+
convo_id: self.convo_id.into_static(),
282
+
message: self.message.into_static(),
283
+
rev: self.rev.into_static(),
284
+
extra_data: self.extra_data.into_static(),
285
+
}
286
+
}
287
+
}
288
+
145
289
#[jacquard_derive::lexicon]
146
290
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
147
291
#[serde(rename_all = "camelCase")]
···
152
296
pub rev: jacquard_common::CowStr<'a>,
153
297
}
154
298
299
+
impl jacquard_common::IntoStatic for LogLeaveConvo<'_> {
300
+
type Output = LogLeaveConvo<'static>;
301
+
fn into_static(self) -> Self::Output {
302
+
LogLeaveConvo {
303
+
convo_id: self.convo_id.into_static(),
304
+
rev: self.rev.into_static(),
305
+
extra_data: self.extra_data.into_static(),
306
+
}
307
+
}
308
+
}
309
+
155
310
#[jacquard_derive::lexicon]
156
311
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
157
312
#[serde(rename_all = "camelCase")]
···
162
317
pub rev: jacquard_common::CowStr<'a>,
163
318
}
164
319
320
+
impl jacquard_common::IntoStatic for LogMuteConvo<'_> {
321
+
type Output = LogMuteConvo<'static>;
322
+
fn into_static(self) -> Self::Output {
323
+
LogMuteConvo {
324
+
convo_id: self.convo_id.into_static(),
325
+
rev: self.rev.into_static(),
326
+
extra_data: self.extra_data.into_static(),
327
+
}
328
+
}
329
+
}
330
+
165
331
#[jacquard_derive::lexicon]
166
332
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
167
333
#[serde(rename_all = "camelCase")]
···
179
345
#[serde(tag = "$type")]
180
346
#[serde(bound(deserialize = "'de: 'a"))]
181
347
pub enum LogReadMessageRecordMessage<'a> {}
348
+
impl jacquard_common::IntoStatic for LogReadMessageRecordMessage<'_> {
349
+
type Output = LogReadMessageRecordMessage<'static>;
350
+
fn into_static(self) -> Self::Output {
351
+
match self {
352
+
LogReadMessageRecordMessage::Unknown(v) => {
353
+
LogReadMessageRecordMessage::Unknown(v.into_static())
354
+
}
355
+
}
356
+
}
357
+
}
358
+
359
+
impl jacquard_common::IntoStatic for LogReadMessage<'_> {
360
+
type Output = LogReadMessage<'static>;
361
+
fn into_static(self) -> Self::Output {
362
+
LogReadMessage {
363
+
convo_id: self.convo_id.into_static(),
364
+
message: self.message.into_static(),
365
+
rev: self.rev.into_static(),
366
+
extra_data: self.extra_data.into_static(),
367
+
}
368
+
}
369
+
}
370
+
182
371
#[jacquard_derive::lexicon]
183
372
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
184
373
#[serde(rename_all = "camelCase")]
···
198
387
#[serde(tag = "$type")]
199
388
#[serde(bound(deserialize = "'de: 'a"))]
200
389
pub enum LogRemoveReactionRecordMessage<'a> {}
390
+
impl jacquard_common::IntoStatic for LogRemoveReactionRecordMessage<'_> {
391
+
type Output = LogRemoveReactionRecordMessage<'static>;
392
+
fn into_static(self) -> Self::Output {
393
+
match self {
394
+
LogRemoveReactionRecordMessage::Unknown(v) => {
395
+
LogRemoveReactionRecordMessage::Unknown(v.into_static())
396
+
}
397
+
}
398
+
}
399
+
}
400
+
401
+
impl jacquard_common::IntoStatic for LogRemoveReaction<'_> {
402
+
type Output = LogRemoveReaction<'static>;
403
+
fn into_static(self) -> Self::Output {
404
+
LogRemoveReaction {
405
+
convo_id: self.convo_id.into_static(),
406
+
message: self.message.into_static(),
407
+
reaction: self.reaction.into_static(),
408
+
rev: self.rev.into_static(),
409
+
extra_data: self.extra_data.into_static(),
410
+
}
411
+
}
412
+
}
413
+
201
414
#[jacquard_derive::lexicon]
202
415
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
203
416
#[serde(rename_all = "camelCase")]
···
208
421
pub rev: jacquard_common::CowStr<'a>,
209
422
}
210
423
424
+
impl jacquard_common::IntoStatic for LogUnmuteConvo<'_> {
425
+
type Output = LogUnmuteConvo<'static>;
426
+
fn into_static(self) -> Self::Output {
427
+
LogUnmuteConvo {
428
+
convo_id: self.convo_id.into_static(),
429
+
rev: self.rev.into_static(),
430
+
extra_data: self.extra_data.into_static(),
431
+
}
432
+
}
433
+
}
434
+
211
435
#[jacquard_derive::lexicon]
212
436
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
213
437
#[serde(rename_all = "camelCase")]
···
218
442
pub reaction: crate::chat_bsky::convo::ReactionView<'a>,
219
443
}
220
444
445
+
impl jacquard_common::IntoStatic for MessageAndReactionView<'_> {
446
+
type Output = MessageAndReactionView<'static>;
447
+
fn into_static(self) -> Self::Output {
448
+
MessageAndReactionView {
449
+
message: self.message.into_static(),
450
+
reaction: self.reaction.into_static(),
451
+
extra_data: self.extra_data.into_static(),
452
+
}
453
+
}
454
+
}
455
+
221
456
#[jacquard_derive::lexicon]
222
457
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
223
458
#[serde(rename_all = "camelCase")]
···
242
477
Record(Box<crate::app_bsky::embed::record::Record<'a>>),
243
478
}
244
479
480
+
impl jacquard_common::IntoStatic for MessageInputRecordEmbed<'_> {
481
+
type Output = MessageInputRecordEmbed<'static>;
482
+
fn into_static(self) -> Self::Output {
483
+
match self {
484
+
MessageInputRecordEmbed::Record(v) => {
485
+
MessageInputRecordEmbed::Record(v.into_static())
486
+
}
487
+
MessageInputRecordEmbed::Unknown(v) => {
488
+
MessageInputRecordEmbed::Unknown(v.into_static())
489
+
}
490
+
}
491
+
}
492
+
}
493
+
494
+
impl jacquard_common::IntoStatic for MessageInput<'_> {
495
+
type Output = MessageInput<'static>;
496
+
fn into_static(self) -> Self::Output {
497
+
MessageInput {
498
+
embed: self.embed.into_static(),
499
+
facets: self.facets.into_static(),
500
+
text: self.text.into_static(),
501
+
extra_data: self.extra_data.into_static(),
502
+
}
503
+
}
504
+
}
505
+
245
506
#[jacquard_derive::lexicon]
246
507
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
247
508
#[serde(rename_all = "camelCase")]
···
252
513
pub did: jacquard_common::types::string::Did<'a>,
253
514
#[serde(borrow)]
254
515
pub message_id: jacquard_common::CowStr<'a>,
516
+
}
517
+
518
+
impl jacquard_common::IntoStatic for MessageRef<'_> {
519
+
type Output = MessageRef<'static>;
520
+
fn into_static(self) -> Self::Output {
521
+
MessageRef {
522
+
convo_id: self.convo_id.into_static(),
523
+
did: self.did.into_static(),
524
+
message_id: self.message_id.into_static(),
525
+
extra_data: self.extra_data.into_static(),
526
+
}
527
+
}
255
528
}
256
529
257
530
#[jacquard_derive::lexicon]
···
289
562
RecordView(Box<crate::app_bsky::embed::record::View<'a>>),
290
563
}
291
564
565
+
impl jacquard_common::IntoStatic for MessageViewRecordEmbed<'_> {
566
+
type Output = MessageViewRecordEmbed<'static>;
567
+
fn into_static(self) -> Self::Output {
568
+
match self {
569
+
MessageViewRecordEmbed::RecordView(v) => {
570
+
MessageViewRecordEmbed::RecordView(v.into_static())
571
+
}
572
+
MessageViewRecordEmbed::Unknown(v) => {
573
+
MessageViewRecordEmbed::Unknown(v.into_static())
574
+
}
575
+
}
576
+
}
577
+
}
578
+
579
+
impl jacquard_common::IntoStatic for MessageView<'_> {
580
+
type Output = MessageView<'static>;
581
+
fn into_static(self) -> Self::Output {
582
+
MessageView {
583
+
embed: self.embed.into_static(),
584
+
facets: self.facets.into_static(),
585
+
id: self.id.into_static(),
586
+
reactions: self.reactions.into_static(),
587
+
rev: self.rev.into_static(),
588
+
sender: self.sender.into_static(),
589
+
sent_at: self.sent_at.into_static(),
590
+
text: self.text.into_static(),
591
+
extra_data: self.extra_data.into_static(),
592
+
}
593
+
}
594
+
}
595
+
292
596
#[jacquard_derive::lexicon]
293
597
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
294
598
#[serde(rename_all = "camelCase")]
···
297
601
pub did: jacquard_common::types::string::Did<'a>,
298
602
}
299
603
604
+
impl jacquard_common::IntoStatic for MessageViewSender<'_> {
605
+
type Output = MessageViewSender<'static>;
606
+
fn into_static(self) -> Self::Output {
607
+
MessageViewSender {
608
+
did: self.did.into_static(),
609
+
extra_data: self.extra_data.into_static(),
610
+
}
611
+
}
612
+
}
613
+
300
614
#[jacquard_derive::lexicon]
301
615
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
302
616
#[serde(rename_all = "camelCase")]
···
308
622
pub value: jacquard_common::CowStr<'a>,
309
623
}
310
624
625
+
impl jacquard_common::IntoStatic for ReactionView<'_> {
626
+
type Output = ReactionView<'static>;
627
+
fn into_static(self) -> Self::Output {
628
+
ReactionView {
629
+
created_at: self.created_at.into_static(),
630
+
sender: self.sender.into_static(),
631
+
value: self.value.into_static(),
632
+
extra_data: self.extra_data.into_static(),
633
+
}
634
+
}
635
+
}
636
+
311
637
#[jacquard_derive::lexicon]
312
638
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
313
639
#[serde(rename_all = "camelCase")]
314
640
pub struct ReactionViewSender<'a> {
315
641
#[serde(borrow)]
316
642
pub did: jacquard_common::types::string::Did<'a>,
643
+
}
644
+
645
+
impl jacquard_common::IntoStatic for ReactionViewSender<'_> {
646
+
type Output = ReactionViewSender<'static>;
647
+
fn into_static(self) -> Self::Output {
648
+
ReactionViewSender {
649
+
did: self.did.into_static(),
650
+
extra_data: self.extra_data.into_static(),
651
+
}
652
+
}
317
653
}
+21
-1
crates/jacquard-api/src/chat_bsky/convo/accept_convo.rs
+21
-1
crates/jacquard-api/src/chat_bsky/convo/accept_convo.rs
···
13
13
pub convo_id: jacquard_common::CowStr<'a>,
14
14
}
15
15
16
+
impl jacquard_common::IntoStatic for AcceptConvo<'_> {
17
+
type Output = AcceptConvo<'static>;
18
+
fn into_static(self) -> Self::Output {
19
+
AcceptConvo {
20
+
convo_id: self.convo_id.into_static(),
21
+
extra_data: self.extra_data.into_static(),
22
+
}
23
+
}
24
+
}
25
+
16
26
#[jacquard_derive::lexicon]
17
27
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
18
28
#[serde(rename_all = "camelCase")]
···
23
33
pub rev: std::option::Option<jacquard_common::CowStr<'a>>,
24
34
}
25
35
36
+
impl jacquard_common::IntoStatic for AcceptConvoOutput<'_> {
37
+
type Output = AcceptConvoOutput<'static>;
38
+
fn into_static(self) -> Self::Output {
39
+
AcceptConvoOutput {
40
+
rev: self.rev.into_static(),
41
+
extra_data: self.extra_data.into_static(),
42
+
}
43
+
}
44
+
}
45
+
26
46
impl jacquard_common::types::xrpc::XrpcRequest for AcceptConvo<'_> {
27
47
const NSID: &'static str = "chat.bsky.convo.acceptConvo";
28
48
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
30
50
);
31
51
const OUTPUT_ENCODING: &'static str = "application/json";
32
52
type Output<'de> = AcceptConvoOutput<'de>;
33
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
53
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
34
54
}
+40
crates/jacquard-api/src/chat_bsky/convo/add_reaction.rs
+40
crates/jacquard-api/src/chat_bsky/convo/add_reaction.rs
···
17
17
pub value: jacquard_common::CowStr<'a>,
18
18
}
19
19
20
+
impl jacquard_common::IntoStatic for AddReaction<'_> {
21
+
type Output = AddReaction<'static>;
22
+
fn into_static(self) -> Self::Output {
23
+
AddReaction {
24
+
convo_id: self.convo_id.into_static(),
25
+
message_id: self.message_id.into_static(),
26
+
value: self.value.into_static(),
27
+
extra_data: self.extra_data.into_static(),
28
+
}
29
+
}
30
+
}
31
+
20
32
#[jacquard_derive::lexicon]
21
33
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
22
34
#[serde(rename_all = "camelCase")]
23
35
pub struct AddReactionOutput<'a> {
24
36
#[serde(borrow)]
25
37
pub message: crate::chat_bsky::convo::MessageView<'a>,
38
+
}
39
+
40
+
impl jacquard_common::IntoStatic for AddReactionOutput<'_> {
41
+
type Output = AddReactionOutput<'static>;
42
+
fn into_static(self) -> Self::Output {
43
+
AddReactionOutput {
44
+
message: self.message.into_static(),
45
+
extra_data: self.extra_data.into_static(),
46
+
}
47
+
}
26
48
}
27
49
28
50
#[jacquard_derive::open_union]
···
75
97
Ok(())
76
98
}
77
99
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
100
+
}
101
+
}
102
+
}
103
+
104
+
impl jacquard_common::IntoStatic for AddReactionError<'_> {
105
+
type Output = AddReactionError<'static>;
106
+
fn into_static(self) -> Self::Output {
107
+
match self {
108
+
AddReactionError::ReactionMessageDeleted(v) => {
109
+
AddReactionError::ReactionMessageDeleted(v.into_static())
110
+
}
111
+
AddReactionError::ReactionLimitReached(v) => {
112
+
AddReactionError::ReactionLimitReached(v.into_static())
113
+
}
114
+
AddReactionError::ReactionInvalidValue(v) => {
115
+
AddReactionError::ReactionInvalidValue(v.into_static())
116
+
}
117
+
AddReactionError::Unknown(v) => AddReactionError::Unknown(v.into_static()),
78
118
}
79
119
}
80
120
}
+22
-1
crates/jacquard-api/src/chat_bsky/convo/delete_message_for_self.rs
+22
-1
crates/jacquard-api/src/chat_bsky/convo/delete_message_for_self.rs
···
15
15
pub message_id: jacquard_common::CowStr<'a>,
16
16
}
17
17
18
+
impl jacquard_common::IntoStatic for DeleteMessageForSelf<'_> {
19
+
type Output = DeleteMessageForSelf<'static>;
20
+
fn into_static(self) -> Self::Output {
21
+
DeleteMessageForSelf {
22
+
convo_id: self.convo_id.into_static(),
23
+
message_id: self.message_id.into_static(),
24
+
extra_data: self.extra_data.into_static(),
25
+
}
26
+
}
27
+
}
28
+
18
29
#[jacquard_derive::lexicon]
19
30
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
20
31
#[serde(rename_all = "camelCase")]
···
24
35
pub value: crate::chat_bsky::convo::DeletedMessageView<'a>,
25
36
}
26
37
38
+
impl jacquard_common::IntoStatic for DeleteMessageForSelfOutput<'_> {
39
+
type Output = DeleteMessageForSelfOutput<'static>;
40
+
fn into_static(self) -> Self::Output {
41
+
DeleteMessageForSelfOutput {
42
+
value: self.value.into_static(),
43
+
extra_data: self.extra_data.into_static(),
44
+
}
45
+
}
46
+
}
47
+
27
48
impl jacquard_common::types::xrpc::XrpcRequest for DeleteMessageForSelf<'_> {
28
49
const NSID: &'static str = "chat.bsky.convo.deleteMessageForSelf";
29
50
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
31
52
);
32
53
const OUTPUT_ENCODING: &'static str = "application/json";
33
54
type Output<'de> = DeleteMessageForSelfOutput<'de>;
34
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
55
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
35
56
}
+20
-1
crates/jacquard-api/src/chat_bsky/convo/get_convo.rs
+20
-1
crates/jacquard-api/src/chat_bsky/convo/get_convo.rs
···
12
12
pub convo_id: jacquard_common::CowStr<'a>,
13
13
}
14
14
15
+
impl jacquard_common::IntoStatic for GetConvo<'_> {
16
+
type Output = GetConvo<'static>;
17
+
fn into_static(self) -> Self::Output {
18
+
GetConvo {
19
+
convo_id: self.convo_id.into_static(),
20
+
}
21
+
}
22
+
}
23
+
15
24
#[jacquard_derive::lexicon]
16
25
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
26
#[serde(rename_all = "camelCase")]
···
20
29
pub convo: crate::chat_bsky::convo::ConvoView<'a>,
21
30
}
22
31
32
+
impl jacquard_common::IntoStatic for GetConvoOutput<'_> {
33
+
type Output = GetConvoOutput<'static>;
34
+
fn into_static(self) -> Self::Output {
35
+
GetConvoOutput {
36
+
convo: self.convo.into_static(),
37
+
extra_data: self.extra_data.into_static(),
38
+
}
39
+
}
40
+
}
41
+
23
42
impl jacquard_common::types::xrpc::XrpcRequest for GetConvo<'_> {
24
43
const NSID: &'static str = "chat.bsky.convo.getConvo";
25
44
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
26
45
const OUTPUT_ENCODING: &'static str = "application/json";
27
46
type Output<'de> = GetConvoOutput<'de>;
28
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
47
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
29
48
}
+21
-1
crates/jacquard-api/src/chat_bsky/convo/get_convo_availability.rs
+21
-1
crates/jacquard-api/src/chat_bsky/convo/get_convo_availability.rs
···
12
12
pub members: Vec<jacquard_common::types::string::Did<'a>>,
13
13
}
14
14
15
+
impl jacquard_common::IntoStatic for GetConvoAvailability<'_> {
16
+
type Output = GetConvoAvailability<'static>;
17
+
fn into_static(self) -> Self::Output {
18
+
GetConvoAvailability {
19
+
members: self.members.into_static(),
20
+
}
21
+
}
22
+
}
23
+
15
24
#[jacquard_derive::lexicon]
16
25
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
26
#[serde(rename_all = "camelCase")]
···
22
31
pub convo: std::option::Option<crate::chat_bsky::convo::ConvoView<'a>>,
23
32
}
24
33
34
+
impl jacquard_common::IntoStatic for GetConvoAvailabilityOutput<'_> {
35
+
type Output = GetConvoAvailabilityOutput<'static>;
36
+
fn into_static(self) -> Self::Output {
37
+
GetConvoAvailabilityOutput {
38
+
can_chat: self.can_chat.into_static(),
39
+
convo: self.convo.into_static(),
40
+
extra_data: self.extra_data.into_static(),
41
+
}
42
+
}
43
+
}
44
+
25
45
impl jacquard_common::types::xrpc::XrpcRequest for GetConvoAvailability<'_> {
26
46
const NSID: &'static str = "chat.bsky.convo.getConvoAvailability";
27
47
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
28
48
const OUTPUT_ENCODING: &'static str = "application/json";
29
49
type Output<'de> = GetConvoAvailabilityOutput<'de>;
30
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
50
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
31
51
}
+20
-1
crates/jacquard-api/src/chat_bsky/convo/get_convo_for_members.rs
+20
-1
crates/jacquard-api/src/chat_bsky/convo/get_convo_for_members.rs
···
12
12
pub members: Vec<jacquard_common::types::string::Did<'a>>,
13
13
}
14
14
15
+
impl jacquard_common::IntoStatic for GetConvoForMembers<'_> {
16
+
type Output = GetConvoForMembers<'static>;
17
+
fn into_static(self) -> Self::Output {
18
+
GetConvoForMembers {
19
+
members: self.members.into_static(),
20
+
}
21
+
}
22
+
}
23
+
15
24
#[jacquard_derive::lexicon]
16
25
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
26
#[serde(rename_all = "camelCase")]
···
20
29
pub convo: crate::chat_bsky::convo::ConvoView<'a>,
21
30
}
22
31
32
+
impl jacquard_common::IntoStatic for GetConvoForMembersOutput<'_> {
33
+
type Output = GetConvoForMembersOutput<'static>;
34
+
fn into_static(self) -> Self::Output {
35
+
GetConvoForMembersOutput {
36
+
convo: self.convo.into_static(),
37
+
extra_data: self.extra_data.into_static(),
38
+
}
39
+
}
40
+
}
41
+
23
42
impl jacquard_common::types::xrpc::XrpcRequest for GetConvoForMembers<'_> {
24
43
const NSID: &'static str = "chat.bsky.convo.getConvoForMembers";
25
44
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
26
45
const OUTPUT_ENCODING: &'static str = "application/json";
27
46
type Output<'de> = GetConvoForMembersOutput<'de>;
28
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
47
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
29
48
}
+21
-1
crates/jacquard-api/src/chat_bsky/convo/get_log.rs
+21
-1
crates/jacquard-api/src/chat_bsky/convo/get_log.rs
···
13
13
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
14
14
}
15
15
16
+
impl jacquard_common::IntoStatic for GetLog<'_> {
17
+
type Output = GetLog<'static>;
18
+
fn into_static(self) -> Self::Output {
19
+
GetLog {
20
+
cursor: self.cursor.into_static(),
21
+
}
22
+
}
23
+
}
24
+
16
25
#[jacquard_derive::lexicon]
17
26
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
18
27
#[serde(rename_all = "camelCase")]
···
24
33
pub logs: Vec<jacquard_common::types::value::Data<'a>>,
25
34
}
26
35
36
+
impl jacquard_common::IntoStatic for GetLogOutput<'_> {
37
+
type Output = GetLogOutput<'static>;
38
+
fn into_static(self) -> Self::Output {
39
+
GetLogOutput {
40
+
cursor: self.cursor.into_static(),
41
+
logs: self.logs.into_static(),
42
+
extra_data: self.extra_data.into_static(),
43
+
}
44
+
}
45
+
}
46
+
27
47
impl jacquard_common::types::xrpc::XrpcRequest for GetLog<'_> {
28
48
const NSID: &'static str = "chat.bsky.convo.getLog";
29
49
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
30
50
const OUTPUT_ENCODING: &'static str = "application/json";
31
51
type Output<'de> = GetLogOutput<'de>;
32
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
52
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
33
53
}
+21
-8
crates/jacquard-api/src/chat_bsky/convo/get_messages.rs
+21
-8
crates/jacquard-api/src/chat_bsky/convo/get_messages.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetMessages<'a> {
11
11
#[serde(borrow)]
···
13
13
#[serde(skip_serializing_if = "std::option::Option::is_none")]
14
14
#[serde(borrow)]
15
15
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
16
+
///(default: 50, min: 1, max: 100)
16
17
#[serde(skip_serializing_if = "std::option::Option::is_none")]
17
18
pub limit: std::option::Option<i64>,
18
19
}
19
20
20
-
impl Default for GetMessages<'_> {
21
-
fn default() -> Self {
22
-
Self {
23
-
convo_id: Default::default(),
24
-
cursor: Default::default(),
25
-
limit: Some(50i64),
21
+
impl jacquard_common::IntoStatic for GetMessages<'_> {
22
+
type Output = GetMessages<'static>;
23
+
fn into_static(self) -> Self::Output {
24
+
GetMessages {
25
+
convo_id: self.convo_id.into_static(),
26
+
cursor: self.cursor.into_static(),
27
+
limit: self.limit.into_static(),
26
28
}
27
29
}
28
30
}
···
38
40
pub messages: Vec<jacquard_common::types::value::Data<'a>>,
39
41
}
40
42
43
+
impl jacquard_common::IntoStatic for GetMessagesOutput<'_> {
44
+
type Output = GetMessagesOutput<'static>;
45
+
fn into_static(self) -> Self::Output {
46
+
GetMessagesOutput {
47
+
cursor: self.cursor.into_static(),
48
+
messages: self.messages.into_static(),
49
+
extra_data: self.extra_data.into_static(),
50
+
}
51
+
}
52
+
}
53
+
41
54
impl jacquard_common::types::xrpc::XrpcRequest for GetMessages<'_> {
42
55
const NSID: &'static str = "chat.bsky.convo.getMessages";
43
56
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
44
57
const OUTPUT_ENCODING: &'static str = "application/json";
45
58
type Output<'de> = GetMessagesOutput<'de>;
46
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
59
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
47
60
}
+22
-1
crates/jacquard-api/src/chat_bsky/convo/leave_convo.rs
+22
-1
crates/jacquard-api/src/chat_bsky/convo/leave_convo.rs
···
13
13
pub convo_id: jacquard_common::CowStr<'a>,
14
14
}
15
15
16
+
impl jacquard_common::IntoStatic for LeaveConvo<'_> {
17
+
type Output = LeaveConvo<'static>;
18
+
fn into_static(self) -> Self::Output {
19
+
LeaveConvo {
20
+
convo_id: self.convo_id.into_static(),
21
+
extra_data: self.extra_data.into_static(),
22
+
}
23
+
}
24
+
}
25
+
16
26
#[jacquard_derive::lexicon]
17
27
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
18
28
#[serde(rename_all = "camelCase")]
···
23
33
pub rev: jacquard_common::CowStr<'a>,
24
34
}
25
35
36
+
impl jacquard_common::IntoStatic for LeaveConvoOutput<'_> {
37
+
type Output = LeaveConvoOutput<'static>;
38
+
fn into_static(self) -> Self::Output {
39
+
LeaveConvoOutput {
40
+
convo_id: self.convo_id.into_static(),
41
+
rev: self.rev.into_static(),
42
+
extra_data: self.extra_data.into_static(),
43
+
}
44
+
}
45
+
}
46
+
26
47
impl jacquard_common::types::xrpc::XrpcRequest for LeaveConvo<'_> {
27
48
const NSID: &'static str = "chat.bsky.convo.leaveConvo";
28
49
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
30
51
);
31
52
const OUTPUT_ENCODING: &'static str = "application/json";
32
53
type Output<'de> = LeaveConvoOutput<'de>;
33
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
54
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
34
55
}
+22
-9
crates/jacquard-api/src/chat_bsky/convo/list_convos.rs
+22
-9
crates/jacquard-api/src/chat_bsky/convo/list_convos.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct ListConvos<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
12
#[serde(borrow)]
13
13
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
14
+
///(default: 50, min: 1, max: 100)
14
15
#[serde(skip_serializing_if = "std::option::Option::is_none")]
15
16
pub limit: std::option::Option<i64>,
16
17
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
21
22
pub status: std::option::Option<jacquard_common::CowStr<'a>>,
22
23
}
23
24
24
-
impl Default for ListConvos<'_> {
25
-
fn default() -> Self {
26
-
Self {
27
-
cursor: Default::default(),
28
-
limit: Some(50i64),
29
-
read_state: Default::default(),
30
-
status: Default::default(),
25
+
impl jacquard_common::IntoStatic for ListConvos<'_> {
26
+
type Output = ListConvos<'static>;
27
+
fn into_static(self) -> Self::Output {
28
+
ListConvos {
29
+
cursor: self.cursor.into_static(),
30
+
limit: self.limit.into_static(),
31
+
read_state: self.read_state.into_static(),
32
+
status: self.status.into_static(),
31
33
}
32
34
}
33
35
}
···
43
45
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
44
46
}
45
47
48
+
impl jacquard_common::IntoStatic for ListConvosOutput<'_> {
49
+
type Output = ListConvosOutput<'static>;
50
+
fn into_static(self) -> Self::Output {
51
+
ListConvosOutput {
52
+
convos: self.convos.into_static(),
53
+
cursor: self.cursor.into_static(),
54
+
extra_data: self.extra_data.into_static(),
55
+
}
56
+
}
57
+
}
58
+
46
59
impl jacquard_common::types::xrpc::XrpcRequest for ListConvos<'_> {
47
60
const NSID: &'static str = "chat.bsky.convo.listConvos";
48
61
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
49
62
const OUTPUT_ENCODING: &'static str = "application/json";
50
63
type Output<'de> = ListConvosOutput<'de>;
51
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
64
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
52
65
}
+21
-1
crates/jacquard-api/src/chat_bsky/convo/mute_convo.rs
+21
-1
crates/jacquard-api/src/chat_bsky/convo/mute_convo.rs
···
13
13
pub convo_id: jacquard_common::CowStr<'a>,
14
14
}
15
15
16
+
impl jacquard_common::IntoStatic for MuteConvo<'_> {
17
+
type Output = MuteConvo<'static>;
18
+
fn into_static(self) -> Self::Output {
19
+
MuteConvo {
20
+
convo_id: self.convo_id.into_static(),
21
+
extra_data: self.extra_data.into_static(),
22
+
}
23
+
}
24
+
}
25
+
16
26
#[jacquard_derive::lexicon]
17
27
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
18
28
#[serde(rename_all = "camelCase")]
···
21
31
pub convo: crate::chat_bsky::convo::ConvoView<'a>,
22
32
}
23
33
34
+
impl jacquard_common::IntoStatic for MuteConvoOutput<'_> {
35
+
type Output = MuteConvoOutput<'static>;
36
+
fn into_static(self) -> Self::Output {
37
+
MuteConvoOutput {
38
+
convo: self.convo.into_static(),
39
+
extra_data: self.extra_data.into_static(),
40
+
}
41
+
}
42
+
}
43
+
24
44
impl jacquard_common::types::xrpc::XrpcRequest for MuteConvo<'_> {
25
45
const NSID: &'static str = "chat.bsky.convo.muteConvo";
26
46
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
28
48
);
29
49
const OUTPUT_ENCODING: &'static str = "application/json";
30
50
type Output<'de> = MuteConvoOutput<'de>;
31
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
51
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
32
52
}
+39
crates/jacquard-api/src/chat_bsky/convo/remove_reaction.rs
+39
crates/jacquard-api/src/chat_bsky/convo/remove_reaction.rs
···
17
17
pub value: jacquard_common::CowStr<'a>,
18
18
}
19
19
20
+
impl jacquard_common::IntoStatic for RemoveReaction<'_> {
21
+
type Output = RemoveReaction<'static>;
22
+
fn into_static(self) -> Self::Output {
23
+
RemoveReaction {
24
+
convo_id: self.convo_id.into_static(),
25
+
message_id: self.message_id.into_static(),
26
+
value: self.value.into_static(),
27
+
extra_data: self.extra_data.into_static(),
28
+
}
29
+
}
30
+
}
31
+
20
32
#[jacquard_derive::lexicon]
21
33
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
22
34
#[serde(rename_all = "camelCase")]
···
25
37
pub message: crate::chat_bsky::convo::MessageView<'a>,
26
38
}
27
39
40
+
impl jacquard_common::IntoStatic for RemoveReactionOutput<'_> {
41
+
type Output = RemoveReactionOutput<'static>;
42
+
fn into_static(self) -> Self::Output {
43
+
RemoveReactionOutput {
44
+
message: self.message.into_static(),
45
+
extra_data: self.extra_data.into_static(),
46
+
}
47
+
}
48
+
}
49
+
28
50
#[jacquard_derive::open_union]
29
51
#[derive(
30
52
serde::Serialize,
···
65
87
Ok(())
66
88
}
67
89
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
90
+
}
91
+
}
92
+
}
93
+
94
+
impl jacquard_common::IntoStatic for RemoveReactionError<'_> {
95
+
type Output = RemoveReactionError<'static>;
96
+
fn into_static(self) -> Self::Output {
97
+
match self {
98
+
RemoveReactionError::ReactionMessageDeleted(v) => {
99
+
RemoveReactionError::ReactionMessageDeleted(v.into_static())
100
+
}
101
+
RemoveReactionError::ReactionInvalidValue(v) => {
102
+
RemoveReactionError::ReactionInvalidValue(v.into_static())
103
+
}
104
+
RemoveReactionError::Unknown(v) => {
105
+
RemoveReactionError::Unknown(v.into_static())
106
+
}
68
107
}
69
108
}
70
109
}
+22
-1
crates/jacquard-api/src/chat_bsky/convo/send_message.rs
+22
-1
crates/jacquard-api/src/chat_bsky/convo/send_message.rs
···
15
15
pub message: crate::chat_bsky::convo::MessageInput<'a>,
16
16
}
17
17
18
+
impl jacquard_common::IntoStatic for SendMessage<'_> {
19
+
type Output = SendMessage<'static>;
20
+
fn into_static(self) -> Self::Output {
21
+
SendMessage {
22
+
convo_id: self.convo_id.into_static(),
23
+
message: self.message.into_static(),
24
+
extra_data: self.extra_data.into_static(),
25
+
}
26
+
}
27
+
}
28
+
18
29
#[jacquard_derive::lexicon]
19
30
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
20
31
#[serde(rename_all = "camelCase")]
···
24
35
pub value: crate::chat_bsky::convo::MessageView<'a>,
25
36
}
26
37
38
+
impl jacquard_common::IntoStatic for SendMessageOutput<'_> {
39
+
type Output = SendMessageOutput<'static>;
40
+
fn into_static(self) -> Self::Output {
41
+
SendMessageOutput {
42
+
value: self.value.into_static(),
43
+
extra_data: self.extra_data.into_static(),
44
+
}
45
+
}
46
+
}
47
+
27
48
impl jacquard_common::types::xrpc::XrpcRequest for SendMessage<'_> {
28
49
const NSID: &'static str = "chat.bsky.convo.sendMessage";
29
50
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
31
52
);
32
53
const OUTPUT_ENCODING: &'static str = "application/json";
33
54
type Output<'de> = SendMessageOutput<'de>;
34
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
55
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
35
56
}
+32
-1
crates/jacquard-api/src/chat_bsky/convo/send_message_batch.rs
+32
-1
crates/jacquard-api/src/chat_bsky/convo/send_message_batch.rs
···
15
15
pub message: crate::chat_bsky::convo::MessageInput<'a>,
16
16
}
17
17
18
+
impl jacquard_common::IntoStatic for BatchItem<'_> {
19
+
type Output = BatchItem<'static>;
20
+
fn into_static(self) -> Self::Output {
21
+
BatchItem {
22
+
convo_id: self.convo_id.into_static(),
23
+
message: self.message.into_static(),
24
+
extra_data: self.extra_data.into_static(),
25
+
}
26
+
}
27
+
}
28
+
18
29
#[jacquard_derive::lexicon]
19
30
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
20
31
#[serde(rename_all = "camelCase")]
···
23
34
pub items: Vec<jacquard_common::types::value::Data<'a>>,
24
35
}
25
36
37
+
impl jacquard_common::IntoStatic for SendMessageBatch<'_> {
38
+
type Output = SendMessageBatch<'static>;
39
+
fn into_static(self) -> Self::Output {
40
+
SendMessageBatch {
41
+
items: self.items.into_static(),
42
+
extra_data: self.extra_data.into_static(),
43
+
}
44
+
}
45
+
}
46
+
26
47
#[jacquard_derive::lexicon]
27
48
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
28
49
#[serde(rename_all = "camelCase")]
···
31
52
pub items: Vec<crate::chat_bsky::convo::MessageView<'a>>,
32
53
}
33
54
55
+
impl jacquard_common::IntoStatic for SendMessageBatchOutput<'_> {
56
+
type Output = SendMessageBatchOutput<'static>;
57
+
fn into_static(self) -> Self::Output {
58
+
SendMessageBatchOutput {
59
+
items: self.items.into_static(),
60
+
extra_data: self.extra_data.into_static(),
61
+
}
62
+
}
63
+
}
64
+
34
65
impl jacquard_common::types::xrpc::XrpcRequest for SendMessageBatch<'_> {
35
66
const NSID: &'static str = "chat.bsky.convo.sendMessageBatch";
36
67
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
38
69
);
39
70
const OUTPUT_ENCODING: &'static str = "application/json";
40
71
type Output<'de> = SendMessageBatchOutput<'de>;
41
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
72
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
42
73
}
+21
-1
crates/jacquard-api/src/chat_bsky/convo/unmute_convo.rs
+21
-1
crates/jacquard-api/src/chat_bsky/convo/unmute_convo.rs
···
13
13
pub convo_id: jacquard_common::CowStr<'a>,
14
14
}
15
15
16
+
impl jacquard_common::IntoStatic for UnmuteConvo<'_> {
17
+
type Output = UnmuteConvo<'static>;
18
+
fn into_static(self) -> Self::Output {
19
+
UnmuteConvo {
20
+
convo_id: self.convo_id.into_static(),
21
+
extra_data: self.extra_data.into_static(),
22
+
}
23
+
}
24
+
}
25
+
16
26
#[jacquard_derive::lexicon]
17
27
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
18
28
#[serde(rename_all = "camelCase")]
···
21
31
pub convo: crate::chat_bsky::convo::ConvoView<'a>,
22
32
}
23
33
34
+
impl jacquard_common::IntoStatic for UnmuteConvoOutput<'_> {
35
+
type Output = UnmuteConvoOutput<'static>;
36
+
fn into_static(self) -> Self::Output {
37
+
UnmuteConvoOutput {
38
+
convo: self.convo.into_static(),
39
+
extra_data: self.extra_data.into_static(),
40
+
}
41
+
}
42
+
}
43
+
24
44
impl jacquard_common::types::xrpc::XrpcRequest for UnmuteConvo<'_> {
25
45
const NSID: &'static str = "chat.bsky.convo.unmuteConvo";
26
46
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
28
48
);
29
49
const OUTPUT_ENCODING: &'static str = "application/json";
30
50
type Output<'de> = UnmuteConvoOutput<'de>;
31
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
51
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
32
52
}
+21
-1
crates/jacquard-api/src/chat_bsky/convo/update_all_read.rs
+21
-1
crates/jacquard-api/src/chat_bsky/convo/update_all_read.rs
···
14
14
pub status: std::option::Option<jacquard_common::CowStr<'a>>,
15
15
}
16
16
17
+
impl jacquard_common::IntoStatic for UpdateAllRead<'_> {
18
+
type Output = UpdateAllRead<'static>;
19
+
fn into_static(self) -> Self::Output {
20
+
UpdateAllRead {
21
+
status: self.status.into_static(),
22
+
extra_data: self.extra_data.into_static(),
23
+
}
24
+
}
25
+
}
26
+
17
27
#[jacquard_derive::lexicon]
18
28
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
19
29
#[serde(rename_all = "camelCase")]
···
22
32
pub updated_count: i64,
23
33
}
24
34
35
+
impl jacquard_common::IntoStatic for UpdateAllReadOutput<'_> {
36
+
type Output = UpdateAllReadOutput<'static>;
37
+
fn into_static(self) -> Self::Output {
38
+
UpdateAllReadOutput {
39
+
updated_count: self.updated_count.into_static(),
40
+
extra_data: self.extra_data.into_static(),
41
+
}
42
+
}
43
+
}
44
+
25
45
impl jacquard_common::types::xrpc::XrpcRequest for UpdateAllRead<'_> {
26
46
const NSID: &'static str = "chat.bsky.convo.updateAllRead";
27
47
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
29
49
);
30
50
const OUTPUT_ENCODING: &'static str = "application/json";
31
51
type Output<'de> = UpdateAllReadOutput<'de>;
32
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
52
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
33
53
}
+22
-1
crates/jacquard-api/src/chat_bsky/convo/update_read.rs
+22
-1
crates/jacquard-api/src/chat_bsky/convo/update_read.rs
···
16
16
pub message_id: std::option::Option<jacquard_common::CowStr<'a>>,
17
17
}
18
18
19
+
impl jacquard_common::IntoStatic for UpdateRead<'_> {
20
+
type Output = UpdateRead<'static>;
21
+
fn into_static(self) -> Self::Output {
22
+
UpdateRead {
23
+
convo_id: self.convo_id.into_static(),
24
+
message_id: self.message_id.into_static(),
25
+
extra_data: self.extra_data.into_static(),
26
+
}
27
+
}
28
+
}
29
+
19
30
#[jacquard_derive::lexicon]
20
31
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
21
32
#[serde(rename_all = "camelCase")]
···
24
35
pub convo: crate::chat_bsky::convo::ConvoView<'a>,
25
36
}
26
37
38
+
impl jacquard_common::IntoStatic for UpdateReadOutput<'_> {
39
+
type Output = UpdateReadOutput<'static>;
40
+
fn into_static(self) -> Self::Output {
41
+
UpdateReadOutput {
42
+
convo: self.convo.into_static(),
43
+
extra_data: self.extra_data.into_static(),
44
+
}
45
+
}
46
+
}
47
+
27
48
impl jacquard_common::types::xrpc::XrpcRequest for UpdateRead<'_> {
28
49
const NSID: &'static str = "chat.bsky.convo.updateRead";
29
50
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
31
52
);
32
53
const OUTPUT_ENCODING: &'static str = "application/json";
33
54
type Output<'de> = UpdateReadOutput<'de>;
34
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
55
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
35
56
}
+35
-1
crates/jacquard-api/src/chat_bsky/moderation/get_actor_metadata.rs
+35
-1
crates/jacquard-api/src/chat_bsky/moderation/get_actor_metadata.rs
···
12
12
pub actor: jacquard_common::types::string::Did<'a>,
13
13
}
14
14
15
+
impl jacquard_common::IntoStatic for GetActorMetadata<'_> {
16
+
type Output = GetActorMetadata<'static>;
17
+
fn into_static(self) -> Self::Output {
18
+
GetActorMetadata {
19
+
actor: self.actor.into_static(),
20
+
}
21
+
}
22
+
}
23
+
15
24
#[jacquard_derive::lexicon]
16
25
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
26
#[serde(rename_all = "camelCase")]
···
24
33
pub month: jacquard_common::types::value::Data<'a>,
25
34
}
26
35
36
+
impl jacquard_common::IntoStatic for GetActorMetadataOutput<'_> {
37
+
type Output = GetActorMetadataOutput<'static>;
38
+
fn into_static(self) -> Self::Output {
39
+
GetActorMetadataOutput {
40
+
all: self.all.into_static(),
41
+
day: self.day.into_static(),
42
+
month: self.month.into_static(),
43
+
extra_data: self.extra_data.into_static(),
44
+
}
45
+
}
46
+
}
47
+
27
48
impl jacquard_common::types::xrpc::XrpcRequest for GetActorMetadata<'_> {
28
49
const NSID: &'static str = "chat.bsky.moderation.getActorMetadata";
29
50
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
30
51
const OUTPUT_ENCODING: &'static str = "application/json";
31
52
type Output<'de> = GetActorMetadataOutput<'de>;
32
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
53
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
33
54
}
34
55
35
56
#[jacquard_derive::lexicon]
···
40
61
pub convos_started: i64,
41
62
pub messages_received: i64,
42
63
pub messages_sent: i64,
64
+
}
65
+
66
+
impl jacquard_common::IntoStatic for Metadata<'_> {
67
+
type Output = Metadata<'static>;
68
+
fn into_static(self) -> Self::Output {
69
+
Metadata {
70
+
convos: self.convos.into_static(),
71
+
convos_started: self.convos_started.into_static(),
72
+
messages_received: self.messages_received.into_static(),
73
+
messages_sent: self.messages_sent.into_static(),
74
+
extra_data: self.extra_data.into_static(),
75
+
}
76
+
}
43
77
}
+22
-9
crates/jacquard-api/src/chat_bsky/moderation/get_message_context.rs
+22
-9
crates/jacquard-api/src/chat_bsky/moderation/get_message_context.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetMessageContext<'a> {
11
+
///(default: 5)
11
12
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
13
pub after: std::option::Option<i64>,
14
+
///(default: 5)
13
15
#[serde(skip_serializing_if = "std::option::Option::is_none")]
14
16
pub before: std::option::Option<i64>,
15
17
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
19
21
pub message_id: jacquard_common::CowStr<'a>,
20
22
}
21
23
22
-
impl Default for GetMessageContext<'_> {
23
-
fn default() -> Self {
24
-
Self {
25
-
after: Some(5i64),
26
-
before: Some(5i64),
27
-
convo_id: Default::default(),
28
-
message_id: Default::default(),
24
+
impl jacquard_common::IntoStatic for GetMessageContext<'_> {
25
+
type Output = GetMessageContext<'static>;
26
+
fn into_static(self) -> Self::Output {
27
+
GetMessageContext {
28
+
after: self.after.into_static(),
29
+
before: self.before.into_static(),
30
+
convo_id: self.convo_id.into_static(),
31
+
message_id: self.message_id.into_static(),
29
32
}
30
33
}
31
34
}
···
38
41
pub messages: Vec<jacquard_common::types::value::Data<'a>>,
39
42
}
40
43
44
+
impl jacquard_common::IntoStatic for GetMessageContextOutput<'_> {
45
+
type Output = GetMessageContextOutput<'static>;
46
+
fn into_static(self) -> Self::Output {
47
+
GetMessageContextOutput {
48
+
messages: self.messages.into_static(),
49
+
extra_data: self.extra_data.into_static(),
50
+
}
51
+
}
52
+
}
53
+
41
54
impl jacquard_common::types::xrpc::XrpcRequest for GetMessageContext<'_> {
42
55
const NSID: &'static str = "chat.bsky.moderation.getMessageContext";
43
56
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
44
57
const OUTPUT_ENCODING: &'static str = "application/json";
45
58
type Output<'de> = GetMessageContextOutput<'de>;
46
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
59
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
47
60
}
+13
-1
crates/jacquard-api/src/chat_bsky/moderation/update_actor_access.rs
+13
-1
crates/jacquard-api/src/chat_bsky/moderation/update_actor_access.rs
···
17
17
pub r#ref: std::option::Option<jacquard_common::CowStr<'a>>,
18
18
}
19
19
20
+
impl jacquard_common::IntoStatic for UpdateActorAccess<'_> {
21
+
type Output = UpdateActorAccess<'static>;
22
+
fn into_static(self) -> Self::Output {
23
+
UpdateActorAccess {
24
+
actor: self.actor.into_static(),
25
+
allow_access: self.allow_access.into_static(),
26
+
r#ref: self.r#ref.into_static(),
27
+
extra_data: self.extra_data.into_static(),
28
+
}
29
+
}
30
+
}
31
+
20
32
impl jacquard_common::types::xrpc::XrpcRequest for UpdateActorAccess<'_> {
21
33
const NSID: &'static str = "chat.bsky.moderation.updateActorAccess";
22
34
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
24
36
);
25
37
const OUTPUT_ENCODING: &'static str = "application/json";
26
38
type Output<'de> = ();
27
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
39
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
28
40
}
+65
crates/jacquard-api/src/com_atproto/admin.rs
+65
crates/jacquard-api/src/com_atproto/admin.rs
···
62
62
>,
63
63
}
64
64
65
+
impl jacquard_common::IntoStatic for AccountView<'_> {
66
+
type Output = AccountView<'static>;
67
+
fn into_static(self) -> Self::Output {
68
+
AccountView {
69
+
deactivated_at: self.deactivated_at.into_static(),
70
+
did: self.did.into_static(),
71
+
email: self.email.into_static(),
72
+
email_confirmed_at: self.email_confirmed_at.into_static(),
73
+
handle: self.handle.into_static(),
74
+
indexed_at: self.indexed_at.into_static(),
75
+
invite_note: self.invite_note.into_static(),
76
+
invited_by: self.invited_by.into_static(),
77
+
invites: self.invites.into_static(),
78
+
invites_disabled: self.invites_disabled.into_static(),
79
+
related_records: self.related_records.into_static(),
80
+
threat_signatures: self.threat_signatures.into_static(),
81
+
extra_data: self.extra_data.into_static(),
82
+
}
83
+
}
84
+
}
85
+
65
86
#[jacquard_derive::lexicon]
66
87
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
67
88
#[serde(rename_all = "camelCase")]
···
73
94
#[serde(skip_serializing_if = "std::option::Option::is_none")]
74
95
#[serde(borrow)]
75
96
pub record_uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
97
+
}
98
+
99
+
impl jacquard_common::IntoStatic for RepoBlobRef<'_> {
100
+
type Output = RepoBlobRef<'static>;
101
+
fn into_static(self) -> Self::Output {
102
+
RepoBlobRef {
103
+
cid: self.cid.into_static(),
104
+
did: self.did.into_static(),
105
+
record_uri: self.record_uri.into_static(),
106
+
extra_data: self.extra_data.into_static(),
107
+
}
108
+
}
76
109
}
77
110
78
111
#[jacquard_derive::lexicon]
···
83
116
pub did: jacquard_common::types::string::Did<'a>,
84
117
}
85
118
119
+
impl jacquard_common::IntoStatic for RepoRef<'_> {
120
+
type Output = RepoRef<'static>;
121
+
fn into_static(self) -> Self::Output {
122
+
RepoRef {
123
+
did: self.did.into_static(),
124
+
extra_data: self.extra_data.into_static(),
125
+
}
126
+
}
127
+
}
128
+
86
129
#[jacquard_derive::lexicon]
87
130
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
88
131
#[serde(rename_all = "camelCase")]
···
93
136
pub r#ref: std::option::Option<jacquard_common::CowStr<'a>>,
94
137
}
95
138
139
+
impl jacquard_common::IntoStatic for StatusAttr<'_> {
140
+
type Output = StatusAttr<'static>;
141
+
fn into_static(self) -> Self::Output {
142
+
StatusAttr {
143
+
applied: self.applied.into_static(),
144
+
r#ref: self.r#ref.into_static(),
145
+
extra_data: self.extra_data.into_static(),
146
+
}
147
+
}
148
+
}
149
+
96
150
#[jacquard_derive::lexicon]
97
151
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
98
152
#[serde(rename_all = "camelCase")]
···
101
155
pub property: jacquard_common::CowStr<'a>,
102
156
#[serde(borrow)]
103
157
pub value: jacquard_common::CowStr<'a>,
158
+
}
159
+
160
+
impl jacquard_common::IntoStatic for ThreatSignature<'_> {
161
+
type Output = ThreatSignature<'static>;
162
+
fn into_static(self) -> Self::Output {
163
+
ThreatSignature {
164
+
property: self.property.into_static(),
165
+
value: self.value.into_static(),
166
+
extra_data: self.extra_data.into_static(),
167
+
}
168
+
}
104
169
}
+11
-1
crates/jacquard-api/src/com_atproto/admin/delete_account.rs
+11
-1
crates/jacquard-api/src/com_atproto/admin/delete_account.rs
···
13
13
pub did: jacquard_common::types::string::Did<'a>,
14
14
}
15
15
16
+
impl jacquard_common::IntoStatic for DeleteAccount<'_> {
17
+
type Output = DeleteAccount<'static>;
18
+
fn into_static(self) -> Self::Output {
19
+
DeleteAccount {
20
+
did: self.did.into_static(),
21
+
extra_data: self.extra_data.into_static(),
22
+
}
23
+
}
24
+
}
25
+
16
26
impl jacquard_common::types::xrpc::XrpcRequest for DeleteAccount<'_> {
17
27
const NSID: &'static str = "com.atproto.admin.deleteAccount";
18
28
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
20
30
);
21
31
const OUTPUT_ENCODING: &'static str = "application/json";
22
32
type Output<'de> = ();
23
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
33
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
24
34
}
+12
-1
crates/jacquard-api/src/com_atproto/admin/disable_account_invites.rs
+12
-1
crates/jacquard-api/src/com_atproto/admin/disable_account_invites.rs
···
17
17
pub note: std::option::Option<jacquard_common::CowStr<'a>>,
18
18
}
19
19
20
+
impl jacquard_common::IntoStatic for DisableAccountInvites<'_> {
21
+
type Output = DisableAccountInvites<'static>;
22
+
fn into_static(self) -> Self::Output {
23
+
DisableAccountInvites {
24
+
account: self.account.into_static(),
25
+
note: self.note.into_static(),
26
+
extra_data: self.extra_data.into_static(),
27
+
}
28
+
}
29
+
}
30
+
20
31
impl jacquard_common::types::xrpc::XrpcRequest for DisableAccountInvites<'_> {
21
32
const NSID: &'static str = "com.atproto.admin.disableAccountInvites";
22
33
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
24
35
);
25
36
const OUTPUT_ENCODING: &'static str = "application/json";
26
37
type Output<'de> = ();
27
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
38
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
28
39
}
+12
-1
crates/jacquard-api/src/com_atproto/admin/disable_invite_codes.rs
+12
-1
crates/jacquard-api/src/com_atproto/admin/disable_invite_codes.rs
···
17
17
pub codes: std::option::Option<Vec<jacquard_common::CowStr<'a>>>,
18
18
}
19
19
20
+
impl jacquard_common::IntoStatic for DisableInviteCodes<'_> {
21
+
type Output = DisableInviteCodes<'static>;
22
+
fn into_static(self) -> Self::Output {
23
+
DisableInviteCodes {
24
+
accounts: self.accounts.into_static(),
25
+
codes: self.codes.into_static(),
26
+
extra_data: self.extra_data.into_static(),
27
+
}
28
+
}
29
+
}
30
+
20
31
impl jacquard_common::types::xrpc::XrpcRequest for DisableInviteCodes<'_> {
21
32
const NSID: &'static str = "com.atproto.admin.disableInviteCodes";
22
33
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
24
35
);
25
36
const OUTPUT_ENCODING: &'static str = "application/json";
26
37
type Output<'de> = ();
27
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
38
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
28
39
}
+12
-1
crates/jacquard-api/src/com_atproto/admin/enable_account_invites.rs
+12
-1
crates/jacquard-api/src/com_atproto/admin/enable_account_invites.rs
···
17
17
pub note: std::option::Option<jacquard_common::CowStr<'a>>,
18
18
}
19
19
20
+
impl jacquard_common::IntoStatic for EnableAccountInvites<'_> {
21
+
type Output = EnableAccountInvites<'static>;
22
+
fn into_static(self) -> Self::Output {
23
+
EnableAccountInvites {
24
+
account: self.account.into_static(),
25
+
note: self.note.into_static(),
26
+
extra_data: self.extra_data.into_static(),
27
+
}
28
+
}
29
+
}
30
+
20
31
impl jacquard_common::types::xrpc::XrpcRequest for EnableAccountInvites<'_> {
21
32
const NSID: &'static str = "com.atproto.admin.enableAccountInvites";
22
33
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
24
35
);
25
36
const OUTPUT_ENCODING: &'static str = "application/json";
26
37
type Output<'de> = ();
27
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
38
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
28
39
}
+20
-1
crates/jacquard-api/src/com_atproto/admin/get_account_info.rs
+20
-1
crates/jacquard-api/src/com_atproto/admin/get_account_info.rs
···
12
12
pub did: jacquard_common::types::string::Did<'a>,
13
13
}
14
14
15
+
impl jacquard_common::IntoStatic for GetAccountInfo<'_> {
16
+
type Output = GetAccountInfo<'static>;
17
+
fn into_static(self) -> Self::Output {
18
+
GetAccountInfo {
19
+
did: self.did.into_static(),
20
+
}
21
+
}
22
+
}
23
+
15
24
#[jacquard_derive::lexicon]
16
25
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
26
#[serde(rename_all = "camelCase")]
···
21
30
pub value: crate::com_atproto::admin::AccountView<'a>,
22
31
}
23
32
33
+
impl jacquard_common::IntoStatic for GetAccountInfoOutput<'_> {
34
+
type Output = GetAccountInfoOutput<'static>;
35
+
fn into_static(self) -> Self::Output {
36
+
GetAccountInfoOutput {
37
+
value: self.value.into_static(),
38
+
extra_data: self.extra_data.into_static(),
39
+
}
40
+
}
41
+
}
42
+
24
43
impl jacquard_common::types::xrpc::XrpcRequest for GetAccountInfo<'_> {
25
44
const NSID: &'static str = "com.atproto.admin.getAccountInfo";
26
45
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
27
46
const OUTPUT_ENCODING: &'static str = "application/json";
28
47
type Output<'de> = GetAccountInfoOutput<'de>;
29
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
48
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
30
49
}
+20
-1
crates/jacquard-api/src/com_atproto/admin/get_account_infos.rs
+20
-1
crates/jacquard-api/src/com_atproto/admin/get_account_infos.rs
···
12
12
pub dids: Vec<jacquard_common::types::string::Did<'a>>,
13
13
}
14
14
15
+
impl jacquard_common::IntoStatic for GetAccountInfos<'_> {
16
+
type Output = GetAccountInfos<'static>;
17
+
fn into_static(self) -> Self::Output {
18
+
GetAccountInfos {
19
+
dids: self.dids.into_static(),
20
+
}
21
+
}
22
+
}
23
+
15
24
#[jacquard_derive::lexicon]
16
25
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
26
#[serde(rename_all = "camelCase")]
···
20
29
pub infos: Vec<crate::com_atproto::admin::AccountView<'a>>,
21
30
}
22
31
32
+
impl jacquard_common::IntoStatic for GetAccountInfosOutput<'_> {
33
+
type Output = GetAccountInfosOutput<'static>;
34
+
fn into_static(self) -> Self::Output {
35
+
GetAccountInfosOutput {
36
+
infos: self.infos.into_static(),
37
+
extra_data: self.extra_data.into_static(),
38
+
}
39
+
}
40
+
}
41
+
23
42
impl jacquard_common::types::xrpc::XrpcRequest for GetAccountInfos<'_> {
24
43
const NSID: &'static str = "com.atproto.admin.getAccountInfos";
25
44
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
26
45
const OUTPUT_ENCODING: &'static str = "application/json";
27
46
type Output<'de> = GetAccountInfosOutput<'de>;
28
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
47
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
29
48
}
+22
-8
crates/jacquard-api/src/com_atproto/admin/get_invite_codes.rs
+22
-8
crates/jacquard-api/src/com_atproto/admin/get_invite_codes.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetInviteCodes<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
12
#[serde(borrow)]
13
13
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
14
+
///(default: 100, min: 1, max: 500)
14
15
#[serde(skip_serializing_if = "std::option::Option::is_none")]
15
16
pub limit: std::option::Option<i64>,
17
+
///(default: "recent")
16
18
#[serde(skip_serializing_if = "std::option::Option::is_none")]
17
19
#[serde(borrow)]
18
20
pub sort: std::option::Option<jacquard_common::CowStr<'a>>,
19
21
}
20
22
21
-
impl Default for GetInviteCodes<'_> {
22
-
fn default() -> Self {
23
-
Self {
24
-
cursor: Default::default(),
25
-
limit: Some(100i64),
26
-
sort: Some(jacquard_common::CowStr::from("recent")),
23
+
impl jacquard_common::IntoStatic for GetInviteCodes<'_> {
24
+
type Output = GetInviteCodes<'static>;
25
+
fn into_static(self) -> Self::Output {
26
+
GetInviteCodes {
27
+
cursor: self.cursor.into_static(),
28
+
limit: self.limit.into_static(),
29
+
sort: self.sort.into_static(),
27
30
}
28
31
}
29
32
}
···
39
42
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
40
43
}
41
44
45
+
impl jacquard_common::IntoStatic for GetInviteCodesOutput<'_> {
46
+
type Output = GetInviteCodesOutput<'static>;
47
+
fn into_static(self) -> Self::Output {
48
+
GetInviteCodesOutput {
49
+
codes: self.codes.into_static(),
50
+
cursor: self.cursor.into_static(),
51
+
extra_data: self.extra_data.into_static(),
52
+
}
53
+
}
54
+
}
55
+
42
56
impl jacquard_common::types::xrpc::XrpcRequest for GetInviteCodes<'_> {
43
57
const NSID: &'static str = "com.atproto.admin.getInviteCodes";
44
58
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
45
59
const OUTPUT_ENCODING: &'static str = "application/json";
46
60
type Output<'de> = GetInviteCodesOutput<'de>;
47
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
61
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
48
62
}
+44
-1
crates/jacquard-api/src/com_atproto/admin/get_subject_status.rs
+44
-1
crates/jacquard-api/src/com_atproto/admin/get_subject_status.rs
···
19
19
pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
20
20
}
21
21
22
+
impl jacquard_common::IntoStatic for GetSubjectStatus<'_> {
23
+
type Output = GetSubjectStatus<'static>;
24
+
fn into_static(self) -> Self::Output {
25
+
GetSubjectStatus {
26
+
blob: self.blob.into_static(),
27
+
did: self.did.into_static(),
28
+
uri: self.uri.into_static(),
29
+
}
30
+
}
31
+
}
32
+
22
33
#[jacquard_derive::lexicon]
23
34
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
24
35
#[serde(rename_all = "camelCase")]
···
46
57
DefsRepoBlobRef(Box<crate::com_atproto::admin::RepoBlobRef<'a>>),
47
58
}
48
59
60
+
impl jacquard_common::IntoStatic for GetSubjectStatusOutputRecordSubject<'_> {
61
+
type Output = GetSubjectStatusOutputRecordSubject<'static>;
62
+
fn into_static(self) -> Self::Output {
63
+
match self {
64
+
GetSubjectStatusOutputRecordSubject::DefsRepoRef(v) => {
65
+
GetSubjectStatusOutputRecordSubject::DefsRepoRef(v.into_static())
66
+
}
67
+
GetSubjectStatusOutputRecordSubject::StrongRef(v) => {
68
+
GetSubjectStatusOutputRecordSubject::StrongRef(v.into_static())
69
+
}
70
+
GetSubjectStatusOutputRecordSubject::DefsRepoBlobRef(v) => {
71
+
GetSubjectStatusOutputRecordSubject::DefsRepoBlobRef(v.into_static())
72
+
}
73
+
GetSubjectStatusOutputRecordSubject::Unknown(v) => {
74
+
GetSubjectStatusOutputRecordSubject::Unknown(v.into_static())
75
+
}
76
+
}
77
+
}
78
+
}
79
+
80
+
impl jacquard_common::IntoStatic for GetSubjectStatusOutput<'_> {
81
+
type Output = GetSubjectStatusOutput<'static>;
82
+
fn into_static(self) -> Self::Output {
83
+
GetSubjectStatusOutput {
84
+
deactivated: self.deactivated.into_static(),
85
+
subject: self.subject.into_static(),
86
+
takedown: self.takedown.into_static(),
87
+
extra_data: self.extra_data.into_static(),
88
+
}
89
+
}
90
+
}
91
+
49
92
impl jacquard_common::types::xrpc::XrpcRequest for GetSubjectStatus<'_> {
50
93
const NSID: &'static str = "com.atproto.admin.getSubjectStatus";
51
94
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
52
95
const OUTPUT_ENCODING: &'static str = "application/json";
53
96
type Output<'de> = GetSubjectStatusOutput<'de>;
54
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
97
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
55
98
}
+21
-8
crates/jacquard-api/src/com_atproto/admin/search_accounts.rs
+21
-8
crates/jacquard-api/src/com_atproto/admin/search_accounts.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct SearchAccounts<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
14
14
#[serde(skip_serializing_if = "std::option::Option::is_none")]
15
15
#[serde(borrow)]
16
16
pub email: std::option::Option<jacquard_common::CowStr<'a>>,
17
+
///(default: 50, min: 1, max: 100)
17
18
#[serde(skip_serializing_if = "std::option::Option::is_none")]
18
19
pub limit: std::option::Option<i64>,
19
20
}
20
21
21
-
impl Default for SearchAccounts<'_> {
22
-
fn default() -> Self {
23
-
Self {
24
-
cursor: Default::default(),
25
-
email: Default::default(),
26
-
limit: Some(50i64),
22
+
impl jacquard_common::IntoStatic for SearchAccounts<'_> {
23
+
type Output = SearchAccounts<'static>;
24
+
fn into_static(self) -> Self::Output {
25
+
SearchAccounts {
26
+
cursor: self.cursor.into_static(),
27
+
email: self.email.into_static(),
28
+
limit: self.limit.into_static(),
27
29
}
28
30
}
29
31
}
···
39
41
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
40
42
}
41
43
44
+
impl jacquard_common::IntoStatic for SearchAccountsOutput<'_> {
45
+
type Output = SearchAccountsOutput<'static>;
46
+
fn into_static(self) -> Self::Output {
47
+
SearchAccountsOutput {
48
+
accounts: self.accounts.into_static(),
49
+
cursor: self.cursor.into_static(),
50
+
extra_data: self.extra_data.into_static(),
51
+
}
52
+
}
53
+
}
54
+
42
55
impl jacquard_common::types::xrpc::XrpcRequest for SearchAccounts<'_> {
43
56
const NSID: &'static str = "com.atproto.admin.searchAccounts";
44
57
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
45
58
const OUTPUT_ENCODING: &'static str = "application/json";
46
59
type Output<'de> = SearchAccountsOutput<'de>;
47
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
60
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
48
61
}
+25
-1
crates/jacquard-api/src/com_atproto/admin/send_email.rs
+25
-1
crates/jacquard-api/src/com_atproto/admin/send_email.rs
···
24
24
pub subject: std::option::Option<jacquard_common::CowStr<'a>>,
25
25
}
26
26
27
+
impl jacquard_common::IntoStatic for SendEmail<'_> {
28
+
type Output = SendEmail<'static>;
29
+
fn into_static(self) -> Self::Output {
30
+
SendEmail {
31
+
comment: self.comment.into_static(),
32
+
content: self.content.into_static(),
33
+
recipient_did: self.recipient_did.into_static(),
34
+
sender_did: self.sender_did.into_static(),
35
+
subject: self.subject.into_static(),
36
+
extra_data: self.extra_data.into_static(),
37
+
}
38
+
}
39
+
}
40
+
27
41
#[jacquard_derive::lexicon]
28
42
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
29
43
#[serde(rename_all = "camelCase")]
···
31
45
pub sent: bool,
32
46
}
33
47
48
+
impl jacquard_common::IntoStatic for SendEmailOutput<'_> {
49
+
type Output = SendEmailOutput<'static>;
50
+
fn into_static(self) -> Self::Output {
51
+
SendEmailOutput {
52
+
sent: self.sent.into_static(),
53
+
extra_data: self.extra_data.into_static(),
54
+
}
55
+
}
56
+
}
57
+
34
58
impl jacquard_common::types::xrpc::XrpcRequest for SendEmail<'_> {
35
59
const NSID: &'static str = "com.atproto.admin.sendEmail";
36
60
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
38
62
);
39
63
const OUTPUT_ENCODING: &'static str = "application/json";
40
64
type Output<'de> = SendEmailOutput<'de>;
41
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
65
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
42
66
}
+12
-1
crates/jacquard-api/src/com_atproto/admin/update_account_email.rs
+12
-1
crates/jacquard-api/src/com_atproto/admin/update_account_email.rs
···
16
16
pub email: jacquard_common::CowStr<'a>,
17
17
}
18
18
19
+
impl jacquard_common::IntoStatic for UpdateAccountEmail<'_> {
20
+
type Output = UpdateAccountEmail<'static>;
21
+
fn into_static(self) -> Self::Output {
22
+
UpdateAccountEmail {
23
+
account: self.account.into_static(),
24
+
email: self.email.into_static(),
25
+
extra_data: self.extra_data.into_static(),
26
+
}
27
+
}
28
+
}
29
+
19
30
impl jacquard_common::types::xrpc::XrpcRequest for UpdateAccountEmail<'_> {
20
31
const NSID: &'static str = "com.atproto.admin.updateAccountEmail";
21
32
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
23
34
);
24
35
const OUTPUT_ENCODING: &'static str = "application/json";
25
36
type Output<'de> = ();
26
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
37
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
27
38
}
+12
-1
crates/jacquard-api/src/com_atproto/admin/update_account_handle.rs
+12
-1
crates/jacquard-api/src/com_atproto/admin/update_account_handle.rs
···
15
15
pub handle: jacquard_common::types::string::Handle<'a>,
16
16
}
17
17
18
+
impl jacquard_common::IntoStatic for UpdateAccountHandle<'_> {
19
+
type Output = UpdateAccountHandle<'static>;
20
+
fn into_static(self) -> Self::Output {
21
+
UpdateAccountHandle {
22
+
did: self.did.into_static(),
23
+
handle: self.handle.into_static(),
24
+
extra_data: self.extra_data.into_static(),
25
+
}
26
+
}
27
+
}
28
+
18
29
impl jacquard_common::types::xrpc::XrpcRequest for UpdateAccountHandle<'_> {
19
30
const NSID: &'static str = "com.atproto.admin.updateAccountHandle";
20
31
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
22
33
);
23
34
const OUTPUT_ENCODING: &'static str = "application/json";
24
35
type Output<'de> = ();
25
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
36
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
26
37
}
+12
-1
crates/jacquard-api/src/com_atproto/admin/update_account_password.rs
+12
-1
crates/jacquard-api/src/com_atproto/admin/update_account_password.rs
···
15
15
pub password: jacquard_common::CowStr<'a>,
16
16
}
17
17
18
+
impl jacquard_common::IntoStatic for UpdateAccountPassword<'_> {
19
+
type Output = UpdateAccountPassword<'static>;
20
+
fn into_static(self) -> Self::Output {
21
+
UpdateAccountPassword {
22
+
did: self.did.into_static(),
23
+
password: self.password.into_static(),
24
+
extra_data: self.extra_data.into_static(),
25
+
}
26
+
}
27
+
}
28
+
18
29
impl jacquard_common::types::xrpc::XrpcRequest for UpdateAccountPassword<'_> {
19
30
const NSID: &'static str = "com.atproto.admin.updateAccountPassword";
20
31
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
22
33
);
23
34
const OUTPUT_ENCODING: &'static str = "application/json";
24
35
type Output<'de> = ();
25
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
36
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
26
37
}
+12
-1
crates/jacquard-api/src/com_atproto/admin/update_account_signing_key.rs
+12
-1
crates/jacquard-api/src/com_atproto/admin/update_account_signing_key.rs
···
16
16
pub signing_key: jacquard_common::types::string::Did<'a>,
17
17
}
18
18
19
+
impl jacquard_common::IntoStatic for UpdateAccountSigningKey<'_> {
20
+
type Output = UpdateAccountSigningKey<'static>;
21
+
fn into_static(self) -> Self::Output {
22
+
UpdateAccountSigningKey {
23
+
did: self.did.into_static(),
24
+
signing_key: self.signing_key.into_static(),
25
+
extra_data: self.extra_data.into_static(),
26
+
}
27
+
}
28
+
}
29
+
19
30
impl jacquard_common::types::xrpc::XrpcRequest for UpdateAccountSigningKey<'_> {
20
31
const NSID: &'static str = "com.atproto.admin.updateAccountSigningKey";
21
32
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
23
34
);
24
35
const OUTPUT_ENCODING: &'static str = "application/json";
25
36
type Output<'de> = ();
26
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
37
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
27
38
}
+64
-1
crates/jacquard-api/src/com_atproto/admin/update_subject_status.rs
+64
-1
crates/jacquard-api/src/com_atproto/admin/update_subject_status.rs
···
32
32
DefsRepoBlobRef(Box<crate::com_atproto::admin::RepoBlobRef<'a>>),
33
33
}
34
34
35
+
impl jacquard_common::IntoStatic for UpdateSubjectStatusRecordSubject<'_> {
36
+
type Output = UpdateSubjectStatusRecordSubject<'static>;
37
+
fn into_static(self) -> Self::Output {
38
+
match self {
39
+
UpdateSubjectStatusRecordSubject::DefsRepoRef(v) => {
40
+
UpdateSubjectStatusRecordSubject::DefsRepoRef(v.into_static())
41
+
}
42
+
UpdateSubjectStatusRecordSubject::StrongRef(v) => {
43
+
UpdateSubjectStatusRecordSubject::StrongRef(v.into_static())
44
+
}
45
+
UpdateSubjectStatusRecordSubject::DefsRepoBlobRef(v) => {
46
+
UpdateSubjectStatusRecordSubject::DefsRepoBlobRef(v.into_static())
47
+
}
48
+
UpdateSubjectStatusRecordSubject::Unknown(v) => {
49
+
UpdateSubjectStatusRecordSubject::Unknown(v.into_static())
50
+
}
51
+
}
52
+
}
53
+
}
54
+
55
+
impl jacquard_common::IntoStatic for UpdateSubjectStatus<'_> {
56
+
type Output = UpdateSubjectStatus<'static>;
57
+
fn into_static(self) -> Self::Output {
58
+
UpdateSubjectStatus {
59
+
deactivated: self.deactivated.into_static(),
60
+
subject: self.subject.into_static(),
61
+
takedown: self.takedown.into_static(),
62
+
extra_data: self.extra_data.into_static(),
63
+
}
64
+
}
65
+
}
66
+
35
67
#[jacquard_derive::lexicon]
36
68
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
37
69
#[serde(rename_all = "camelCase")]
···
56
88
DefsRepoBlobRef(Box<crate::com_atproto::admin::RepoBlobRef<'a>>),
57
89
}
58
90
91
+
impl jacquard_common::IntoStatic for UpdateSubjectStatusOutputRecordSubject<'_> {
92
+
type Output = UpdateSubjectStatusOutputRecordSubject<'static>;
93
+
fn into_static(self) -> Self::Output {
94
+
match self {
95
+
UpdateSubjectStatusOutputRecordSubject::DefsRepoRef(v) => {
96
+
UpdateSubjectStatusOutputRecordSubject::DefsRepoRef(v.into_static())
97
+
}
98
+
UpdateSubjectStatusOutputRecordSubject::StrongRef(v) => {
99
+
UpdateSubjectStatusOutputRecordSubject::StrongRef(v.into_static())
100
+
}
101
+
UpdateSubjectStatusOutputRecordSubject::DefsRepoBlobRef(v) => {
102
+
UpdateSubjectStatusOutputRecordSubject::DefsRepoBlobRef(v.into_static())
103
+
}
104
+
UpdateSubjectStatusOutputRecordSubject::Unknown(v) => {
105
+
UpdateSubjectStatusOutputRecordSubject::Unknown(v.into_static())
106
+
}
107
+
}
108
+
}
109
+
}
110
+
111
+
impl jacquard_common::IntoStatic for UpdateSubjectStatusOutput<'_> {
112
+
type Output = UpdateSubjectStatusOutput<'static>;
113
+
fn into_static(self) -> Self::Output {
114
+
UpdateSubjectStatusOutput {
115
+
subject: self.subject.into_static(),
116
+
takedown: self.takedown.into_static(),
117
+
extra_data: self.extra_data.into_static(),
118
+
}
119
+
}
120
+
}
121
+
59
122
impl jacquard_common::types::xrpc::XrpcRequest for UpdateSubjectStatus<'_> {
60
123
const NSID: &'static str = "com.atproto.admin.updateSubjectStatus";
61
124
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
63
126
);
64
127
const OUTPUT_ENCODING: &'static str = "application/json";
65
128
type Output<'de> = UpdateSubjectStatusOutput<'de>;
66
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
129
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
67
130
}
+12
crates/jacquard-api/src/com_atproto/identity.rs
+12
crates/jacquard-api/src/com_atproto/identity.rs
···
27
27
///The validated handle of the account; or 'handle.invalid' if the handle did not bi-directionally match the DID document.
28
28
#[serde(borrow)]
29
29
pub handle: jacquard_common::types::string::Handle<'a>,
30
+
}
31
+
32
+
impl jacquard_common::IntoStatic for IdentityInfo<'_> {
33
+
type Output = IdentityInfo<'static>;
34
+
fn into_static(self) -> Self::Output {
35
+
IdentityInfo {
36
+
did: self.did.into_static(),
37
+
did_doc: self.did_doc.into_static(),
38
+
handle: self.handle.into_static(),
39
+
extra_data: self.extra_data.into_static(),
40
+
}
41
+
}
30
42
}
+14
-1
crates/jacquard-api/src/com_atproto/identity/get_recommended_did_credentials.rs
+14
-1
crates/jacquard-api/src/com_atproto/identity/get_recommended_did_credentials.rs
···
26
26
>,
27
27
}
28
28
29
+
impl jacquard_common::IntoStatic for GetRecommendedDidCredentialsOutput<'_> {
30
+
type Output = GetRecommendedDidCredentialsOutput<'static>;
31
+
fn into_static(self) -> Self::Output {
32
+
GetRecommendedDidCredentialsOutput {
33
+
also_known_as: self.also_known_as.into_static(),
34
+
rotation_keys: self.rotation_keys.into_static(),
35
+
services: self.services.into_static(),
36
+
verification_methods: self.verification_methods.into_static(),
37
+
extra_data: self.extra_data.into_static(),
38
+
}
39
+
}
40
+
}
41
+
29
42
/// XRPC request marker type
30
43
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]
31
44
pub struct GetRecommendedDidCredentials;
···
34
47
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
35
48
const OUTPUT_ENCODING: &'static str = "application/json";
36
49
type Output<'de> = GetRecommendedDidCredentialsOutput<'de>;
37
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
50
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
38
51
}
+40
crates/jacquard-api/src/com_atproto/identity/refresh_identity.rs
+40
crates/jacquard-api/src/com_atproto/identity/refresh_identity.rs
···
13
13
pub identifier: jacquard_common::types::ident::AtIdentifier<'a>,
14
14
}
15
15
16
+
impl jacquard_common::IntoStatic for RefreshIdentity<'_> {
17
+
type Output = RefreshIdentity<'static>;
18
+
fn into_static(self) -> Self::Output {
19
+
RefreshIdentity {
20
+
identifier: self.identifier.into_static(),
21
+
extra_data: self.extra_data.into_static(),
22
+
}
23
+
}
24
+
}
25
+
16
26
#[jacquard_derive::lexicon]
17
27
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
18
28
#[serde(rename_all = "camelCase")]
···
20
30
#[serde(flatten)]
21
31
#[serde(borrow)]
22
32
pub value: crate::com_atproto::identity::IdentityInfo<'a>,
33
+
}
34
+
35
+
impl jacquard_common::IntoStatic for RefreshIdentityOutput<'_> {
36
+
type Output = RefreshIdentityOutput<'static>;
37
+
fn into_static(self) -> Self::Output {
38
+
RefreshIdentityOutput {
39
+
value: self.value.into_static(),
40
+
extra_data: self.extra_data.into_static(),
41
+
}
42
+
}
23
43
}
24
44
25
45
#[jacquard_derive::open_union]
···
72
92
Ok(())
73
93
}
74
94
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
95
+
}
96
+
}
97
+
}
98
+
99
+
impl jacquard_common::IntoStatic for RefreshIdentityError<'_> {
100
+
type Output = RefreshIdentityError<'static>;
101
+
fn into_static(self) -> Self::Output {
102
+
match self {
103
+
RefreshIdentityError::HandleNotFound(v) => {
104
+
RefreshIdentityError::HandleNotFound(v.into_static())
105
+
}
106
+
RefreshIdentityError::DidNotFound(v) => {
107
+
RefreshIdentityError::DidNotFound(v.into_static())
108
+
}
109
+
RefreshIdentityError::DidDeactivated(v) => {
110
+
RefreshIdentityError::DidDeactivated(v.into_static())
111
+
}
112
+
RefreshIdentityError::Unknown(v) => {
113
+
RefreshIdentityError::Unknown(v.into_static())
114
+
}
75
115
}
76
116
}
77
117
}
+1
-1
crates/jacquard-api/src/com_atproto/identity/request_plc_operation_signature.rs
+1
-1
crates/jacquard-api/src/com_atproto/identity/request_plc_operation_signature.rs
+34
crates/jacquard-api/src/com_atproto/identity/resolve_did.rs
+34
crates/jacquard-api/src/com_atproto/identity/resolve_did.rs
···
12
12
pub did: jacquard_common::types::string::Did<'a>,
13
13
}
14
14
15
+
impl jacquard_common::IntoStatic for ResolveDid<'_> {
16
+
type Output = ResolveDid<'static>;
17
+
fn into_static(self) -> Self::Output {
18
+
ResolveDid {
19
+
did: self.did.into_static(),
20
+
}
21
+
}
22
+
}
23
+
15
24
#[jacquard_derive::lexicon]
16
25
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
26
#[serde(rename_all = "camelCase")]
···
19
28
///The complete DID document for the identity.
20
29
#[serde(borrow)]
21
30
pub did_doc: jacquard_common::types::value::Data<'a>,
31
+
}
32
+
33
+
impl jacquard_common::IntoStatic for ResolveDidOutput<'_> {
34
+
type Output = ResolveDidOutput<'static>;
35
+
fn into_static(self) -> Self::Output {
36
+
ResolveDidOutput {
37
+
did_doc: self.did_doc.into_static(),
38
+
extra_data: self.extra_data.into_static(),
39
+
}
40
+
}
22
41
}
23
42
24
43
#[jacquard_derive::open_union]
···
61
80
Ok(())
62
81
}
63
82
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
83
+
}
84
+
}
85
+
}
86
+
87
+
impl jacquard_common::IntoStatic for ResolveDidError<'_> {
88
+
type Output = ResolveDidError<'static>;
89
+
fn into_static(self) -> Self::Output {
90
+
match self {
91
+
ResolveDidError::DidNotFound(v) => {
92
+
ResolveDidError::DidNotFound(v.into_static())
93
+
}
94
+
ResolveDidError::DidDeactivated(v) => {
95
+
ResolveDidError::DidDeactivated(v.into_static())
96
+
}
97
+
ResolveDidError::Unknown(v) => ResolveDidError::Unknown(v.into_static()),
64
98
}
65
99
}
66
100
}
+33
crates/jacquard-api/src/com_atproto/identity/resolve_handle.rs
+33
crates/jacquard-api/src/com_atproto/identity/resolve_handle.rs
···
12
12
pub handle: jacquard_common::types::string::Handle<'a>,
13
13
}
14
14
15
+
impl jacquard_common::IntoStatic for ResolveHandle<'_> {
16
+
type Output = ResolveHandle<'static>;
17
+
fn into_static(self) -> Self::Output {
18
+
ResolveHandle {
19
+
handle: self.handle.into_static(),
20
+
}
21
+
}
22
+
}
23
+
15
24
#[jacquard_derive::lexicon]
16
25
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
26
#[serde(rename_all = "camelCase")]
···
20
29
pub did: jacquard_common::types::string::Did<'a>,
21
30
}
22
31
32
+
impl jacquard_common::IntoStatic for ResolveHandleOutput<'_> {
33
+
type Output = ResolveHandleOutput<'static>;
34
+
fn into_static(self) -> Self::Output {
35
+
ResolveHandleOutput {
36
+
did: self.did.into_static(),
37
+
extra_data: self.extra_data.into_static(),
38
+
}
39
+
}
40
+
}
41
+
23
42
#[jacquard_derive::open_union]
24
43
#[derive(
25
44
serde::Serialize,
···
50
69
Ok(())
51
70
}
52
71
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
72
+
}
73
+
}
74
+
}
75
+
76
+
impl jacquard_common::IntoStatic for ResolveHandleError<'_> {
77
+
type Output = ResolveHandleError<'static>;
78
+
fn into_static(self) -> Self::Output {
79
+
match self {
80
+
ResolveHandleError::HandleNotFound(v) => {
81
+
ResolveHandleError::HandleNotFound(v.into_static())
82
+
}
83
+
ResolveHandleError::Unknown(v) => {
84
+
ResolveHandleError::Unknown(v.into_static())
85
+
}
53
86
}
54
87
}
55
88
}
+39
crates/jacquard-api/src/com_atproto/identity/resolve_identity.rs
+39
crates/jacquard-api/src/com_atproto/identity/resolve_identity.rs
···
12
12
pub identifier: jacquard_common::types::ident::AtIdentifier<'a>,
13
13
}
14
14
15
+
impl jacquard_common::IntoStatic for ResolveIdentity<'_> {
16
+
type Output = ResolveIdentity<'static>;
17
+
fn into_static(self) -> Self::Output {
18
+
ResolveIdentity {
19
+
identifier: self.identifier.into_static(),
20
+
}
21
+
}
22
+
}
23
+
15
24
#[jacquard_derive::lexicon]
16
25
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
26
#[serde(rename_all = "camelCase")]
···
19
28
#[serde(flatten)]
20
29
#[serde(borrow)]
21
30
pub value: crate::com_atproto::identity::IdentityInfo<'a>,
31
+
}
32
+
33
+
impl jacquard_common::IntoStatic for ResolveIdentityOutput<'_> {
34
+
type Output = ResolveIdentityOutput<'static>;
35
+
fn into_static(self) -> Self::Output {
36
+
ResolveIdentityOutput {
37
+
value: self.value.into_static(),
38
+
extra_data: self.extra_data.into_static(),
39
+
}
40
+
}
22
41
}
23
42
24
43
#[jacquard_derive::open_union]
···
71
90
Ok(())
72
91
}
73
92
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
93
+
}
94
+
}
95
+
}
96
+
97
+
impl jacquard_common::IntoStatic for ResolveIdentityError<'_> {
98
+
type Output = ResolveIdentityError<'static>;
99
+
fn into_static(self) -> Self::Output {
100
+
match self {
101
+
ResolveIdentityError::HandleNotFound(v) => {
102
+
ResolveIdentityError::HandleNotFound(v.into_static())
103
+
}
104
+
ResolveIdentityError::DidNotFound(v) => {
105
+
ResolveIdentityError::DidNotFound(v.into_static())
106
+
}
107
+
ResolveIdentityError::DidDeactivated(v) => {
108
+
ResolveIdentityError::DidDeactivated(v.into_static())
109
+
}
110
+
ResolveIdentityError::Unknown(v) => {
111
+
ResolveIdentityError::Unknown(v.into_static())
112
+
}
74
113
}
75
114
}
76
115
}
+25
-1
crates/jacquard-api/src/com_atproto/identity/sign_plc_operation.rs
+25
-1
crates/jacquard-api/src/com_atproto/identity/sign_plc_operation.rs
···
29
29
>,
30
30
}
31
31
32
+
impl jacquard_common::IntoStatic for SignPlcOperation<'_> {
33
+
type Output = SignPlcOperation<'static>;
34
+
fn into_static(self) -> Self::Output {
35
+
SignPlcOperation {
36
+
also_known_as: self.also_known_as.into_static(),
37
+
rotation_keys: self.rotation_keys.into_static(),
38
+
services: self.services.into_static(),
39
+
token: self.token.into_static(),
40
+
verification_methods: self.verification_methods.into_static(),
41
+
extra_data: self.extra_data.into_static(),
42
+
}
43
+
}
44
+
}
45
+
32
46
#[jacquard_derive::lexicon]
33
47
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
34
48
#[serde(rename_all = "camelCase")]
···
38
52
pub operation: jacquard_common::types::value::Data<'a>,
39
53
}
40
54
55
+
impl jacquard_common::IntoStatic for SignPlcOperationOutput<'_> {
56
+
type Output = SignPlcOperationOutput<'static>;
57
+
fn into_static(self) -> Self::Output {
58
+
SignPlcOperationOutput {
59
+
operation: self.operation.into_static(),
60
+
extra_data: self.extra_data.into_static(),
61
+
}
62
+
}
63
+
}
64
+
41
65
impl jacquard_common::types::xrpc::XrpcRequest for SignPlcOperation<'_> {
42
66
const NSID: &'static str = "com.atproto.identity.signPlcOperation";
43
67
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
45
69
);
46
70
const OUTPUT_ENCODING: &'static str = "application/json";
47
71
type Output<'de> = SignPlcOperationOutput<'de>;
48
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
72
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
49
73
}
+11
-1
crates/jacquard-api/src/com_atproto/identity/submit_plc_operation.rs
+11
-1
crates/jacquard-api/src/com_atproto/identity/submit_plc_operation.rs
···
13
13
pub operation: jacquard_common::types::value::Data<'a>,
14
14
}
15
15
16
+
impl jacquard_common::IntoStatic for SubmitPlcOperation<'_> {
17
+
type Output = SubmitPlcOperation<'static>;
18
+
fn into_static(self) -> Self::Output {
19
+
SubmitPlcOperation {
20
+
operation: self.operation.into_static(),
21
+
extra_data: self.extra_data.into_static(),
22
+
}
23
+
}
24
+
}
25
+
16
26
impl jacquard_common::types::xrpc::XrpcRequest for SubmitPlcOperation<'_> {
17
27
const NSID: &'static str = "com.atproto.identity.submitPlcOperation";
18
28
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
20
30
);
21
31
const OUTPUT_ENCODING: &'static str = "application/json";
22
32
type Output<'de> = ();
23
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
33
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
24
34
}
+11
-1
crates/jacquard-api/src/com_atproto/identity/update_handle.rs
+11
-1
crates/jacquard-api/src/com_atproto/identity/update_handle.rs
···
14
14
pub handle: jacquard_common::types::string::Handle<'a>,
15
15
}
16
16
17
+
impl jacquard_common::IntoStatic for UpdateHandle<'_> {
18
+
type Output = UpdateHandle<'static>;
19
+
fn into_static(self) -> Self::Output {
20
+
UpdateHandle {
21
+
handle: self.handle.into_static(),
22
+
extra_data: self.extra_data.into_static(),
23
+
}
24
+
}
25
+
}
26
+
17
27
impl jacquard_common::types::xrpc::XrpcRequest for UpdateHandle<'_> {
18
28
const NSID: &'static str = "com.atproto.identity.updateHandle";
19
29
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
21
31
);
22
32
const OUTPUT_ENCODING: &'static str = "application/json";
23
33
type Output<'de> = ();
24
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
34
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
25
35
}
+85
crates/jacquard-api/src/com_atproto/label.rs
+85
crates/jacquard-api/src/com_atproto/label.rs
···
42
42
pub ver: std::option::Option<i64>,
43
43
}
44
44
45
+
impl jacquard_common::IntoStatic for Label<'_> {
46
+
type Output = Label<'static>;
47
+
fn into_static(self) -> Self::Output {
48
+
Label {
49
+
cid: self.cid.into_static(),
50
+
cts: self.cts.into_static(),
51
+
exp: self.exp.into_static(),
52
+
neg: self.neg.into_static(),
53
+
sig: self.sig.into_static(),
54
+
src: self.src.into_static(),
55
+
uri: self.uri.into_static(),
56
+
val: self.val.into_static(),
57
+
ver: self.ver.into_static(),
58
+
extra_data: self.extra_data.into_static(),
59
+
}
60
+
}
61
+
}
62
+
45
63
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
46
64
pub enum LabelValue<'a> {
47
65
Hide,
···
143
161
}
144
162
}
145
163
164
+
impl jacquard_common::IntoStatic for LabelValue<'_> {
165
+
type Output = LabelValue<'static>;
166
+
fn into_static(self) -> Self::Output {
167
+
match self {
168
+
LabelValue::Hide => LabelValue::Hide,
169
+
LabelValue::NoPromote => LabelValue::NoPromote,
170
+
LabelValue::Warn => LabelValue::Warn,
171
+
LabelValue::NoUnauthenticated => LabelValue::NoUnauthenticated,
172
+
LabelValue::DmcaViolation => LabelValue::DmcaViolation,
173
+
LabelValue::Doxxing => LabelValue::Doxxing,
174
+
LabelValue::Porn => LabelValue::Porn,
175
+
LabelValue::Sexual => LabelValue::Sexual,
176
+
LabelValue::Nudity => LabelValue::Nudity,
177
+
LabelValue::Nsfl => LabelValue::Nsfl,
178
+
LabelValue::Gore => LabelValue::Gore,
179
+
LabelValue::Other(v) => LabelValue::Other(v.into_static()),
180
+
}
181
+
}
182
+
}
183
+
146
184
///Declares a label value and its expected interpretations and behaviors.
147
185
#[jacquard_derive::lexicon]
148
186
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
168
206
pub severity: jacquard_common::CowStr<'a>,
169
207
}
170
208
209
+
impl jacquard_common::IntoStatic for LabelValueDefinition<'_> {
210
+
type Output = LabelValueDefinition<'static>;
211
+
fn into_static(self) -> Self::Output {
212
+
LabelValueDefinition {
213
+
adult_only: self.adult_only.into_static(),
214
+
blurs: self.blurs.into_static(),
215
+
default_setting: self.default_setting.into_static(),
216
+
identifier: self.identifier.into_static(),
217
+
locales: self.locales.into_static(),
218
+
severity: self.severity.into_static(),
219
+
extra_data: self.extra_data.into_static(),
220
+
}
221
+
}
222
+
}
223
+
171
224
///Strings which describe the label in the UI, localized into a specific language.
172
225
#[jacquard_derive::lexicon]
173
226
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
183
236
pub name: jacquard_common::CowStr<'a>,
184
237
}
185
238
239
+
impl jacquard_common::IntoStatic for LabelValueDefinitionStrings<'_> {
240
+
type Output = LabelValueDefinitionStrings<'static>;
241
+
fn into_static(self) -> Self::Output {
242
+
LabelValueDefinitionStrings {
243
+
description: self.description.into_static(),
244
+
lang: self.lang.into_static(),
245
+
name: self.name.into_static(),
246
+
extra_data: self.extra_data.into_static(),
247
+
}
248
+
}
249
+
}
250
+
186
251
///Metadata tag on an atproto record, published by the author within the record. Note that schemas should use #selfLabels, not #selfLabel.
187
252
#[jacquard_derive::lexicon]
188
253
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
191
256
///The short string name of the value or type of this label.
192
257
#[serde(borrow)]
193
258
pub val: jacquard_common::CowStr<'a>,
259
+
}
260
+
261
+
impl jacquard_common::IntoStatic for SelfLabel<'_> {
262
+
type Output = SelfLabel<'static>;
263
+
fn into_static(self) -> Self::Output {
264
+
SelfLabel {
265
+
val: self.val.into_static(),
266
+
extra_data: self.extra_data.into_static(),
267
+
}
268
+
}
194
269
}
195
270
196
271
///Metadata tags on an atproto record, published by the author within the record.
···
200
275
pub struct SelfLabels<'a> {
201
276
#[serde(borrow)]
202
277
pub values: Vec<crate::com_atproto::label::SelfLabel<'a>>,
278
+
}
279
+
280
+
impl jacquard_common::IntoStatic for SelfLabels<'_> {
281
+
type Output = SelfLabels<'static>;
282
+
fn into_static(self) -> Self::Output {
283
+
SelfLabels {
284
+
values: self.values.into_static(),
285
+
extra_data: self.extra_data.into_static(),
286
+
}
287
+
}
203
288
}
+22
-9
crates/jacquard-api/src/com_atproto/label/query_labels.rs
+22
-9
crates/jacquard-api/src/com_atproto/label/query_labels.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct QueryLabels<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
12
#[serde(borrow)]
13
13
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
14
+
///(default: 50, min: 1, max: 250)
14
15
#[serde(skip_serializing_if = "std::option::Option::is_none")]
15
16
pub limit: std::option::Option<i64>,
16
17
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
20
21
pub uri_patterns: Vec<jacquard_common::CowStr<'a>>,
21
22
}
22
23
23
-
impl Default for QueryLabels<'_> {
24
-
fn default() -> Self {
25
-
Self {
26
-
cursor: Default::default(),
27
-
limit: Some(50i64),
28
-
sources: Default::default(),
29
-
uri_patterns: Default::default(),
24
+
impl jacquard_common::IntoStatic for QueryLabels<'_> {
25
+
type Output = QueryLabels<'static>;
26
+
fn into_static(self) -> Self::Output {
27
+
QueryLabels {
28
+
cursor: self.cursor.into_static(),
29
+
limit: self.limit.into_static(),
30
+
sources: self.sources.into_static(),
31
+
uri_patterns: self.uri_patterns.into_static(),
30
32
}
31
33
}
32
34
}
···
42
44
pub labels: Vec<crate::com_atproto::label::Label<'a>>,
43
45
}
44
46
47
+
impl jacquard_common::IntoStatic for QueryLabelsOutput<'_> {
48
+
type Output = QueryLabelsOutput<'static>;
49
+
fn into_static(self) -> Self::Output {
50
+
QueryLabelsOutput {
51
+
cursor: self.cursor.into_static(),
52
+
labels: self.labels.into_static(),
53
+
extra_data: self.extra_data.into_static(),
54
+
}
55
+
}
56
+
}
57
+
45
58
impl jacquard_common::types::xrpc::XrpcRequest for QueryLabels<'_> {
46
59
const NSID: &'static str = "com.atproto.label.queryLabels";
47
60
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
48
61
const OUTPUT_ENCODING: &'static str = "application/json";
49
62
type Output<'de> = QueryLabelsOutput<'de>;
50
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
63
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
51
64
}
+60
crates/jacquard-api/src/com_atproto/label/subscribe_labels.rs
+60
crates/jacquard-api/src/com_atproto/label/subscribe_labels.rs
···
16
16
pub name: jacquard_common::CowStr<'a>,
17
17
}
18
18
19
+
impl jacquard_common::IntoStatic for Info<'_> {
20
+
type Output = Info<'static>;
21
+
fn into_static(self) -> Self::Output {
22
+
Info {
23
+
message: self.message.into_static(),
24
+
name: self.name.into_static(),
25
+
extra_data: self.extra_data.into_static(),
26
+
}
27
+
}
28
+
}
29
+
19
30
#[jacquard_derive::lexicon]
20
31
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
21
32
#[serde(rename_all = "camelCase")]
···
25
36
pub seq: i64,
26
37
}
27
38
39
+
impl jacquard_common::IntoStatic for Labels<'_> {
40
+
type Output = Labels<'static>;
41
+
fn into_static(self) -> Self::Output {
42
+
Labels {
43
+
labels: self.labels.into_static(),
44
+
seq: self.seq.into_static(),
45
+
extra_data: self.extra_data.into_static(),
46
+
}
47
+
}
48
+
}
49
+
28
50
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
29
51
#[serde(rename_all = "camelCase")]
30
52
pub struct SubscribeLabels {
···
32
54
pub cursor: std::option::Option<i64>,
33
55
}
34
56
57
+
impl jacquard_common::IntoStatic for SubscribeLabels {
58
+
type Output = SubscribeLabels;
59
+
fn into_static(self) -> Self::Output {
60
+
self
61
+
}
62
+
}
63
+
35
64
#[jacquard_derive::open_union]
36
65
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
37
66
#[serde(tag = "$type")]
···
43
72
Info(Box<jacquard_common::types::value::Data<'a>>),
44
73
}
45
74
75
+
impl jacquard_common::IntoStatic for SubscribeLabelsMessage<'_> {
76
+
type Output = SubscribeLabelsMessage<'static>;
77
+
fn into_static(self) -> Self::Output {
78
+
match self {
79
+
SubscribeLabelsMessage::Labels(v) => {
80
+
SubscribeLabelsMessage::Labels(v.into_static())
81
+
}
82
+
SubscribeLabelsMessage::Info(v) => {
83
+
SubscribeLabelsMessage::Info(v.into_static())
84
+
}
85
+
SubscribeLabelsMessage::Unknown(v) => {
86
+
SubscribeLabelsMessage::Unknown(v.into_static())
87
+
}
88
+
}
89
+
}
90
+
}
91
+
46
92
#[jacquard_derive::open_union]
47
93
#[derive(
48
94
serde::Serialize,
···
72
118
Ok(())
73
119
}
74
120
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
121
+
}
122
+
}
123
+
}
124
+
125
+
impl jacquard_common::IntoStatic for SubscribeLabelsError<'_> {
126
+
type Output = SubscribeLabelsError<'static>;
127
+
fn into_static(self) -> Self::Output {
128
+
match self {
129
+
SubscribeLabelsError::FutureCursor(v) => {
130
+
SubscribeLabelsError::FutureCursor(v.into_static())
131
+
}
132
+
SubscribeLabelsError::Unknown(v) => {
133
+
SubscribeLabelsError::Unknown(v.into_static())
134
+
}
75
135
}
76
136
}
77
137
}
+10
crates/jacquard-api/src/com_atproto/lexicon/schema.rs
+10
crates/jacquard-api/src/com_atproto/lexicon/schema.rs
···
16
16
17
17
impl jacquard_common::types::collection::Collection for Schema<'_> {
18
18
const NSID: &'static str = "com.atproto.lexicon.schema";
19
+
}
20
+
21
+
impl jacquard_common::IntoStatic for Schema<'_> {
22
+
type Output = Schema<'static>;
23
+
fn into_static(self) -> Self::Output {
24
+
Schema {
25
+
lexicon: self.lexicon.into_static(),
26
+
extra_data: self.extra_data.into_static(),
27
+
}
28
+
}
19
29
}
+177
crates/jacquard-api/src/com_atproto/moderation.rs
+177
crates/jacquard-api/src/com_atproto/moderation.rs
···
584
584
}
585
585
}
586
586
587
+
impl jacquard_common::IntoStatic for ReasonType<'_> {
588
+
type Output = ReasonType<'static>;
589
+
fn into_static(self) -> Self::Output {
590
+
match self {
591
+
ReasonType::ComAtprotoModerationDefsReasonSpam => {
592
+
ReasonType::ComAtprotoModerationDefsReasonSpam
593
+
}
594
+
ReasonType::ComAtprotoModerationDefsReasonViolation => {
595
+
ReasonType::ComAtprotoModerationDefsReasonViolation
596
+
}
597
+
ReasonType::ComAtprotoModerationDefsReasonMisleading => {
598
+
ReasonType::ComAtprotoModerationDefsReasonMisleading
599
+
}
600
+
ReasonType::ComAtprotoModerationDefsReasonSexual => {
601
+
ReasonType::ComAtprotoModerationDefsReasonSexual
602
+
}
603
+
ReasonType::ComAtprotoModerationDefsReasonRude => {
604
+
ReasonType::ComAtprotoModerationDefsReasonRude
605
+
}
606
+
ReasonType::ComAtprotoModerationDefsReasonOther => {
607
+
ReasonType::ComAtprotoModerationDefsReasonOther
608
+
}
609
+
ReasonType::ComAtprotoModerationDefsReasonAppeal => {
610
+
ReasonType::ComAtprotoModerationDefsReasonAppeal
611
+
}
612
+
ReasonType::ToolsOzoneReportDefsReasonAppeal => {
613
+
ReasonType::ToolsOzoneReportDefsReasonAppeal
614
+
}
615
+
ReasonType::ToolsOzoneReportDefsReasonViolenceAnimalWelfare => {
616
+
ReasonType::ToolsOzoneReportDefsReasonViolenceAnimalWelfare
617
+
}
618
+
ReasonType::ToolsOzoneReportDefsReasonViolenceThreats => {
619
+
ReasonType::ToolsOzoneReportDefsReasonViolenceThreats
620
+
}
621
+
ReasonType::ToolsOzoneReportDefsReasonViolenceGraphicContent => {
622
+
ReasonType::ToolsOzoneReportDefsReasonViolenceGraphicContent
623
+
}
624
+
ReasonType::ToolsOzoneReportDefsReasonViolenceSelfHarm => {
625
+
ReasonType::ToolsOzoneReportDefsReasonViolenceSelfHarm
626
+
}
627
+
ReasonType::ToolsOzoneReportDefsReasonViolenceGlorification => {
628
+
ReasonType::ToolsOzoneReportDefsReasonViolenceGlorification
629
+
}
630
+
ReasonType::ToolsOzoneReportDefsReasonViolenceExtremistContent => {
631
+
ReasonType::ToolsOzoneReportDefsReasonViolenceExtremistContent
632
+
}
633
+
ReasonType::ToolsOzoneReportDefsReasonViolenceTrafficking => {
634
+
ReasonType::ToolsOzoneReportDefsReasonViolenceTrafficking
635
+
}
636
+
ReasonType::ToolsOzoneReportDefsReasonViolenceOther => {
637
+
ReasonType::ToolsOzoneReportDefsReasonViolenceOther
638
+
}
639
+
ReasonType::ToolsOzoneReportDefsReasonSexualAbuseContent => {
640
+
ReasonType::ToolsOzoneReportDefsReasonSexualAbuseContent
641
+
}
642
+
ReasonType::ToolsOzoneReportDefsReasonSexualNcii => {
643
+
ReasonType::ToolsOzoneReportDefsReasonSexualNcii
644
+
}
645
+
ReasonType::ToolsOzoneReportDefsReasonSexualSextortion => {
646
+
ReasonType::ToolsOzoneReportDefsReasonSexualSextortion
647
+
}
648
+
ReasonType::ToolsOzoneReportDefsReasonSexualDeepfake => {
649
+
ReasonType::ToolsOzoneReportDefsReasonSexualDeepfake
650
+
}
651
+
ReasonType::ToolsOzoneReportDefsReasonSexualAnimal => {
652
+
ReasonType::ToolsOzoneReportDefsReasonSexualAnimal
653
+
}
654
+
ReasonType::ToolsOzoneReportDefsReasonSexualUnlabeled => {
655
+
ReasonType::ToolsOzoneReportDefsReasonSexualUnlabeled
656
+
}
657
+
ReasonType::ToolsOzoneReportDefsReasonSexualOther => {
658
+
ReasonType::ToolsOzoneReportDefsReasonSexualOther
659
+
}
660
+
ReasonType::ToolsOzoneReportDefsReasonChildSafetyCsam => {
661
+
ReasonType::ToolsOzoneReportDefsReasonChildSafetyCsam
662
+
}
663
+
ReasonType::ToolsOzoneReportDefsReasonChildSafetyGroom => {
664
+
ReasonType::ToolsOzoneReportDefsReasonChildSafetyGroom
665
+
}
666
+
ReasonType::ToolsOzoneReportDefsReasonChildSafetyMinorPrivacy => {
667
+
ReasonType::ToolsOzoneReportDefsReasonChildSafetyMinorPrivacy
668
+
}
669
+
ReasonType::ToolsOzoneReportDefsReasonChildSafetyEndangerment => {
670
+
ReasonType::ToolsOzoneReportDefsReasonChildSafetyEndangerment
671
+
}
672
+
ReasonType::ToolsOzoneReportDefsReasonChildSafetyHarassment => {
673
+
ReasonType::ToolsOzoneReportDefsReasonChildSafetyHarassment
674
+
}
675
+
ReasonType::ToolsOzoneReportDefsReasonChildSafetyPromotion => {
676
+
ReasonType::ToolsOzoneReportDefsReasonChildSafetyPromotion
677
+
}
678
+
ReasonType::ToolsOzoneReportDefsReasonChildSafetyOther => {
679
+
ReasonType::ToolsOzoneReportDefsReasonChildSafetyOther
680
+
}
681
+
ReasonType::ToolsOzoneReportDefsReasonHarassmentTroll => {
682
+
ReasonType::ToolsOzoneReportDefsReasonHarassmentTroll
683
+
}
684
+
ReasonType::ToolsOzoneReportDefsReasonHarassmentTargeted => {
685
+
ReasonType::ToolsOzoneReportDefsReasonHarassmentTargeted
686
+
}
687
+
ReasonType::ToolsOzoneReportDefsReasonHarassmentHateSpeech => {
688
+
ReasonType::ToolsOzoneReportDefsReasonHarassmentHateSpeech
689
+
}
690
+
ReasonType::ToolsOzoneReportDefsReasonHarassmentDoxxing => {
691
+
ReasonType::ToolsOzoneReportDefsReasonHarassmentDoxxing
692
+
}
693
+
ReasonType::ToolsOzoneReportDefsReasonHarassmentOther => {
694
+
ReasonType::ToolsOzoneReportDefsReasonHarassmentOther
695
+
}
696
+
ReasonType::ToolsOzoneReportDefsReasonMisleadingBot => {
697
+
ReasonType::ToolsOzoneReportDefsReasonMisleadingBot
698
+
}
699
+
ReasonType::ToolsOzoneReportDefsReasonMisleadingImpersonation => {
700
+
ReasonType::ToolsOzoneReportDefsReasonMisleadingImpersonation
701
+
}
702
+
ReasonType::ToolsOzoneReportDefsReasonMisleadingSpam => {
703
+
ReasonType::ToolsOzoneReportDefsReasonMisleadingSpam
704
+
}
705
+
ReasonType::ToolsOzoneReportDefsReasonMisleadingScam => {
706
+
ReasonType::ToolsOzoneReportDefsReasonMisleadingScam
707
+
}
708
+
ReasonType::ToolsOzoneReportDefsReasonMisleadingSyntheticContent => {
709
+
ReasonType::ToolsOzoneReportDefsReasonMisleadingSyntheticContent
710
+
}
711
+
ReasonType::ToolsOzoneReportDefsReasonMisleadingMisinformation => {
712
+
ReasonType::ToolsOzoneReportDefsReasonMisleadingMisinformation
713
+
}
714
+
ReasonType::ToolsOzoneReportDefsReasonMisleadingOther => {
715
+
ReasonType::ToolsOzoneReportDefsReasonMisleadingOther
716
+
}
717
+
ReasonType::ToolsOzoneReportDefsReasonRuleSiteSecurity => {
718
+
ReasonType::ToolsOzoneReportDefsReasonRuleSiteSecurity
719
+
}
720
+
ReasonType::ToolsOzoneReportDefsReasonRuleStolenContent => {
721
+
ReasonType::ToolsOzoneReportDefsReasonRuleStolenContent
722
+
}
723
+
ReasonType::ToolsOzoneReportDefsReasonRuleProhibitedSales => {
724
+
ReasonType::ToolsOzoneReportDefsReasonRuleProhibitedSales
725
+
}
726
+
ReasonType::ToolsOzoneReportDefsReasonRuleBanEvasion => {
727
+
ReasonType::ToolsOzoneReportDefsReasonRuleBanEvasion
728
+
}
729
+
ReasonType::ToolsOzoneReportDefsReasonRuleOther => {
730
+
ReasonType::ToolsOzoneReportDefsReasonRuleOther
731
+
}
732
+
ReasonType::ToolsOzoneReportDefsReasonCivicElectoralProcess => {
733
+
ReasonType::ToolsOzoneReportDefsReasonCivicElectoralProcess
734
+
}
735
+
ReasonType::ToolsOzoneReportDefsReasonCivicDisclosure => {
736
+
ReasonType::ToolsOzoneReportDefsReasonCivicDisclosure
737
+
}
738
+
ReasonType::ToolsOzoneReportDefsReasonCivicInterference => {
739
+
ReasonType::ToolsOzoneReportDefsReasonCivicInterference
740
+
}
741
+
ReasonType::ToolsOzoneReportDefsReasonCivicMisinformation => {
742
+
ReasonType::ToolsOzoneReportDefsReasonCivicMisinformation
743
+
}
744
+
ReasonType::ToolsOzoneReportDefsReasonCivicImpersonation => {
745
+
ReasonType::ToolsOzoneReportDefsReasonCivicImpersonation
746
+
}
747
+
ReasonType::Other(v) => ReasonType::Other(v.into_static()),
748
+
}
749
+
}
750
+
}
751
+
587
752
///Tag describing a type of subject that might be reported.
588
753
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
589
754
pub enum SubjectType<'a> {
···
651
816
{
652
817
let s = <&'de str>::deserialize(deserializer)?;
653
818
Ok(Self::from(s))
819
+
}
820
+
}
821
+
822
+
impl jacquard_common::IntoStatic for SubjectType<'_> {
823
+
type Output = SubjectType<'static>;
824
+
fn into_static(self) -> Self::Output {
825
+
match self {
826
+
SubjectType::Account => SubjectType::Account,
827
+
SubjectType::Record => SubjectType::Record,
828
+
SubjectType::Chat => SubjectType::Chat,
829
+
SubjectType::Other(v) => SubjectType::Other(v.into_static()),
830
+
}
654
831
}
655
832
}
+74
-1
crates/jacquard-api/src/com_atproto/moderation/create_report.rs
+74
-1
crates/jacquard-api/src/com_atproto/moderation/create_report.rs
···
34
34
StrongRef(Box<crate::com_atproto::repo::strong_ref::StrongRef<'a>>),
35
35
}
36
36
37
+
impl jacquard_common::IntoStatic for CreateReportRecordSubject<'_> {
38
+
type Output = CreateReportRecordSubject<'static>;
39
+
fn into_static(self) -> Self::Output {
40
+
match self {
41
+
CreateReportRecordSubject::DefsRepoRef(v) => {
42
+
CreateReportRecordSubject::DefsRepoRef(v.into_static())
43
+
}
44
+
CreateReportRecordSubject::StrongRef(v) => {
45
+
CreateReportRecordSubject::StrongRef(v.into_static())
46
+
}
47
+
CreateReportRecordSubject::Unknown(v) => {
48
+
CreateReportRecordSubject::Unknown(v.into_static())
49
+
}
50
+
}
51
+
}
52
+
}
53
+
54
+
impl jacquard_common::IntoStatic for CreateReport<'_> {
55
+
type Output = CreateReport<'static>;
56
+
fn into_static(self) -> Self::Output {
57
+
CreateReport {
58
+
mod_tool: self.mod_tool.into_static(),
59
+
reason: self.reason.into_static(),
60
+
reason_type: self.reason_type.into_static(),
61
+
subject: self.subject.into_static(),
62
+
extra_data: self.extra_data.into_static(),
63
+
}
64
+
}
65
+
}
66
+
37
67
#[jacquard_derive::lexicon]
38
68
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
39
69
#[serde(rename_all = "camelCase")]
···
62
92
StrongRef(Box<crate::com_atproto::repo::strong_ref::StrongRef<'a>>),
63
93
}
64
94
95
+
impl jacquard_common::IntoStatic for CreateReportOutputRecordSubject<'_> {
96
+
type Output = CreateReportOutputRecordSubject<'static>;
97
+
fn into_static(self) -> Self::Output {
98
+
match self {
99
+
CreateReportOutputRecordSubject::DefsRepoRef(v) => {
100
+
CreateReportOutputRecordSubject::DefsRepoRef(v.into_static())
101
+
}
102
+
CreateReportOutputRecordSubject::StrongRef(v) => {
103
+
CreateReportOutputRecordSubject::StrongRef(v.into_static())
104
+
}
105
+
CreateReportOutputRecordSubject::Unknown(v) => {
106
+
CreateReportOutputRecordSubject::Unknown(v.into_static())
107
+
}
108
+
}
109
+
}
110
+
}
111
+
112
+
impl jacquard_common::IntoStatic for CreateReportOutput<'_> {
113
+
type Output = CreateReportOutput<'static>;
114
+
fn into_static(self) -> Self::Output {
115
+
CreateReportOutput {
116
+
created_at: self.created_at.into_static(),
117
+
id: self.id.into_static(),
118
+
reason: self.reason.into_static(),
119
+
reason_type: self.reason_type.into_static(),
120
+
reported_by: self.reported_by.into_static(),
121
+
subject: self.subject.into_static(),
122
+
extra_data: self.extra_data.into_static(),
123
+
}
124
+
}
125
+
}
126
+
65
127
impl jacquard_common::types::xrpc::XrpcRequest for CreateReport<'_> {
66
128
const NSID: &'static str = "com.atproto.moderation.createReport";
67
129
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
69
131
);
70
132
const OUTPUT_ENCODING: &'static str = "application/json";
71
133
type Output<'de> = CreateReportOutput<'de>;
72
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
134
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
73
135
}
74
136
75
137
///Moderation tool information for tracing the source of the action
···
84
146
///Name/identifier of the source (e.g., 'bsky-app/android', 'bsky-web/chrome')
85
147
#[serde(borrow)]
86
148
pub name: jacquard_common::CowStr<'a>,
149
+
}
150
+
151
+
impl jacquard_common::IntoStatic for ModTool<'_> {
152
+
type Output = ModTool<'static>;
153
+
fn into_static(self) -> Self::Output {
154
+
ModTool {
155
+
meta: self.meta.into_static(),
156
+
name: self.name.into_static(),
157
+
extra_data: self.extra_data.into_static(),
158
+
}
159
+
}
87
160
}
+11
crates/jacquard-api/src/com_atproto/repo.rs
+11
crates/jacquard-api/src/com_atproto/repo.rs
···
24
24
#[serde(borrow)]
25
25
pub cid: jacquard_common::types::string::Cid<'a>,
26
26
pub rev: jacquard_common::types::string::Tid,
27
+
}
28
+
29
+
impl jacquard_common::IntoStatic for CommitMeta<'_> {
30
+
type Output = CommitMeta<'static>;
31
+
fn into_static(self) -> Self::Output {
32
+
CommitMeta {
33
+
cid: self.cid.into_static(),
34
+
rev: self.rev.into_static(),
35
+
extra_data: self.extra_data.into_static(),
36
+
}
37
+
}
27
38
}
+104
crates/jacquard-api/src/com_atproto/repo/apply_writes.rs
+104
crates/jacquard-api/src/com_atproto/repo/apply_writes.rs
···
24
24
pub value: jacquard_common::types::value::Data<'a>,
25
25
}
26
26
27
+
impl jacquard_common::IntoStatic for Create<'_> {
28
+
type Output = Create<'static>;
29
+
fn into_static(self) -> Self::Output {
30
+
Create {
31
+
collection: self.collection.into_static(),
32
+
rkey: self.rkey.into_static(),
33
+
value: self.value.into_static(),
34
+
extra_data: self.extra_data.into_static(),
35
+
}
36
+
}
37
+
}
38
+
27
39
#[jacquard_derive::lexicon]
28
40
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
29
41
#[serde(rename_all = "camelCase")]
···
37
49
pub validation_status: std::option::Option<jacquard_common::CowStr<'a>>,
38
50
}
39
51
52
+
impl jacquard_common::IntoStatic for CreateResult<'_> {
53
+
type Output = CreateResult<'static>;
54
+
fn into_static(self) -> Self::Output {
55
+
CreateResult {
56
+
cid: self.cid.into_static(),
57
+
uri: self.uri.into_static(),
58
+
validation_status: self.validation_status.into_static(),
59
+
extra_data: self.extra_data.into_static(),
60
+
}
61
+
}
62
+
}
63
+
40
64
///Operation which deletes an existing record.
41
65
#[jacquard_derive::lexicon]
42
66
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
50
74
>,
51
75
}
52
76
77
+
impl jacquard_common::IntoStatic for Delete<'_> {
78
+
type Output = Delete<'static>;
79
+
fn into_static(self) -> Self::Output {
80
+
Delete {
81
+
collection: self.collection.into_static(),
82
+
rkey: self.rkey.into_static(),
83
+
extra_data: self.extra_data.into_static(),
84
+
}
85
+
}
86
+
}
87
+
53
88
#[jacquard_derive::lexicon]
54
89
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
55
90
#[serde(rename_all = "camelCase")]
56
91
pub struct DeleteResult<'a> {}
92
+
impl jacquard_common::IntoStatic for DeleteResult<'_> {
93
+
type Output = DeleteResult<'static>;
94
+
fn into_static(self) -> Self::Output {
95
+
DeleteResult {
96
+
extra_data: self.extra_data.into_static(),
97
+
}
98
+
}
99
+
}
100
+
57
101
#[jacquard_derive::lexicon]
58
102
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
59
103
#[serde(rename_all = "camelCase")]
···
72
116
pub writes: Vec<jacquard_common::types::value::Data<'a>>,
73
117
}
74
118
119
+
impl jacquard_common::IntoStatic for ApplyWrites<'_> {
120
+
type Output = ApplyWrites<'static>;
121
+
fn into_static(self) -> Self::Output {
122
+
ApplyWrites {
123
+
repo: self.repo.into_static(),
124
+
swap_commit: self.swap_commit.into_static(),
125
+
validate: self.validate.into_static(),
126
+
writes: self.writes.into_static(),
127
+
extra_data: self.extra_data.into_static(),
128
+
}
129
+
}
130
+
}
131
+
75
132
#[jacquard_derive::lexicon]
76
133
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
77
134
#[serde(rename_all = "camelCase")]
···
82
139
#[serde(skip_serializing_if = "std::option::Option::is_none")]
83
140
#[serde(borrow)]
84
141
pub results: std::option::Option<Vec<jacquard_common::types::value::Data<'a>>>,
142
+
}
143
+
144
+
impl jacquard_common::IntoStatic for ApplyWritesOutput<'_> {
145
+
type Output = ApplyWritesOutput<'static>;
146
+
fn into_static(self) -> Self::Output {
147
+
ApplyWritesOutput {
148
+
commit: self.commit.into_static(),
149
+
results: self.results.into_static(),
150
+
extra_data: self.extra_data.into_static(),
151
+
}
152
+
}
85
153
}
86
154
87
155
#[jacquard_derive::open_union]
···
118
186
}
119
187
}
120
188
189
+
impl jacquard_common::IntoStatic for ApplyWritesError<'_> {
190
+
type Output = ApplyWritesError<'static>;
191
+
fn into_static(self) -> Self::Output {
192
+
match self {
193
+
ApplyWritesError::InvalidSwap(v) => {
194
+
ApplyWritesError::InvalidSwap(v.into_static())
195
+
}
196
+
ApplyWritesError::Unknown(v) => ApplyWritesError::Unknown(v.into_static()),
197
+
}
198
+
}
199
+
}
200
+
121
201
impl jacquard_common::types::xrpc::XrpcRequest for ApplyWrites<'_> {
122
202
const NSID: &'static str = "com.atproto.repo.applyWrites";
123
203
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
143
223
pub value: jacquard_common::types::value::Data<'a>,
144
224
}
145
225
226
+
impl jacquard_common::IntoStatic for Update<'_> {
227
+
type Output = Update<'static>;
228
+
fn into_static(self) -> Self::Output {
229
+
Update {
230
+
collection: self.collection.into_static(),
231
+
rkey: self.rkey.into_static(),
232
+
value: self.value.into_static(),
233
+
extra_data: self.extra_data.into_static(),
234
+
}
235
+
}
236
+
}
237
+
146
238
#[jacquard_derive::lexicon]
147
239
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
148
240
#[serde(rename_all = "camelCase")]
···
154
246
#[serde(skip_serializing_if = "std::option::Option::is_none")]
155
247
#[serde(borrow)]
156
248
pub validation_status: std::option::Option<jacquard_common::CowStr<'a>>,
249
+
}
250
+
251
+
impl jacquard_common::IntoStatic for UpdateResult<'_> {
252
+
type Output = UpdateResult<'static>;
253
+
fn into_static(self) -> Self::Output {
254
+
UpdateResult {
255
+
cid: self.cid.into_static(),
256
+
uri: self.uri.into_static(),
257
+
validation_status: self.validation_status.into_static(),
258
+
extra_data: self.extra_data.into_static(),
259
+
}
260
+
}
157
261
}
+40
crates/jacquard-api/src/com_atproto/repo/create_record.rs
+40
crates/jacquard-api/src/com_atproto/repo/create_record.rs
···
35
35
pub validate: std::option::Option<bool>,
36
36
}
37
37
38
+
impl jacquard_common::IntoStatic for CreateRecord<'_> {
39
+
type Output = CreateRecord<'static>;
40
+
fn into_static(self) -> Self::Output {
41
+
CreateRecord {
42
+
collection: self.collection.into_static(),
43
+
record: self.record.into_static(),
44
+
repo: self.repo.into_static(),
45
+
rkey: self.rkey.into_static(),
46
+
swap_commit: self.swap_commit.into_static(),
47
+
validate: self.validate.into_static(),
48
+
extra_data: self.extra_data.into_static(),
49
+
}
50
+
}
51
+
}
52
+
38
53
#[jacquard_derive::lexicon]
39
54
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
40
55
#[serde(rename_all = "camelCase")]
···
51
66
pub validation_status: std::option::Option<jacquard_common::CowStr<'a>>,
52
67
}
53
68
69
+
impl jacquard_common::IntoStatic for CreateRecordOutput<'_> {
70
+
type Output = CreateRecordOutput<'static>;
71
+
fn into_static(self) -> Self::Output {
72
+
CreateRecordOutput {
73
+
cid: self.cid.into_static(),
74
+
commit: self.commit.into_static(),
75
+
uri: self.uri.into_static(),
76
+
validation_status: self.validation_status.into_static(),
77
+
extra_data: self.extra_data.into_static(),
78
+
}
79
+
}
80
+
}
81
+
54
82
#[jacquard_derive::open_union]
55
83
#[derive(
56
84
serde::Serialize,
···
81
109
Ok(())
82
110
}
83
111
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
112
+
}
113
+
}
114
+
}
115
+
116
+
impl jacquard_common::IntoStatic for CreateRecordError<'_> {
117
+
type Output = CreateRecordError<'static>;
118
+
fn into_static(self) -> Self::Output {
119
+
match self {
120
+
CreateRecordError::InvalidSwap(v) => {
121
+
CreateRecordError::InvalidSwap(v.into_static())
122
+
}
123
+
CreateRecordError::Unknown(v) => CreateRecordError::Unknown(v.into_static()),
84
124
}
85
125
}
86
126
}
+36
crates/jacquard-api/src/com_atproto/repo/delete_record.rs
+36
crates/jacquard-api/src/com_atproto/repo/delete_record.rs
···
30
30
pub swap_record: std::option::Option<jacquard_common::types::string::Cid<'a>>,
31
31
}
32
32
33
+
impl jacquard_common::IntoStatic for DeleteRecord<'_> {
34
+
type Output = DeleteRecord<'static>;
35
+
fn into_static(self) -> Self::Output {
36
+
DeleteRecord {
37
+
collection: self.collection.into_static(),
38
+
repo: self.repo.into_static(),
39
+
rkey: self.rkey.into_static(),
40
+
swap_commit: self.swap_commit.into_static(),
41
+
swap_record: self.swap_record.into_static(),
42
+
extra_data: self.extra_data.into_static(),
43
+
}
44
+
}
45
+
}
46
+
33
47
#[jacquard_derive::lexicon]
34
48
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
35
49
#[serde(rename_all = "camelCase")]
···
39
53
pub commit: std::option::Option<crate::com_atproto::repo::CommitMeta<'a>>,
40
54
}
41
55
56
+
impl jacquard_common::IntoStatic for DeleteRecordOutput<'_> {
57
+
type Output = DeleteRecordOutput<'static>;
58
+
fn into_static(self) -> Self::Output {
59
+
DeleteRecordOutput {
60
+
commit: self.commit.into_static(),
61
+
extra_data: self.extra_data.into_static(),
62
+
}
63
+
}
64
+
}
65
+
42
66
#[jacquard_derive::open_union]
43
67
#[derive(
44
68
serde::Serialize,
···
68
92
Ok(())
69
93
}
70
94
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
95
+
}
96
+
}
97
+
}
98
+
99
+
impl jacquard_common::IntoStatic for DeleteRecordError<'_> {
100
+
type Output = DeleteRecordError<'static>;
101
+
fn into_static(self) -> Self::Output {
102
+
match self {
103
+
DeleteRecordError::InvalidSwap(v) => {
104
+
DeleteRecordError::InvalidSwap(v.into_static())
105
+
}
106
+
DeleteRecordError::Unknown(v) => DeleteRecordError::Unknown(v.into_static()),
71
107
}
72
108
}
73
109
}
+24
-1
crates/jacquard-api/src/com_atproto/repo/describe_repo.rs
+24
-1
crates/jacquard-api/src/com_atproto/repo/describe_repo.rs
···
12
12
pub repo: jacquard_common::types::ident::AtIdentifier<'a>,
13
13
}
14
14
15
+
impl jacquard_common::IntoStatic for DescribeRepo<'_> {
16
+
type Output = DescribeRepo<'static>;
17
+
fn into_static(self) -> Self::Output {
18
+
DescribeRepo {
19
+
repo: self.repo.into_static(),
20
+
}
21
+
}
22
+
}
23
+
15
24
#[jacquard_derive::lexicon]
16
25
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
26
#[serde(rename_all = "camelCase")]
···
30
39
pub handle_is_correct: bool,
31
40
}
32
41
42
+
impl jacquard_common::IntoStatic for DescribeRepoOutput<'_> {
43
+
type Output = DescribeRepoOutput<'static>;
44
+
fn into_static(self) -> Self::Output {
45
+
DescribeRepoOutput {
46
+
collections: self.collections.into_static(),
47
+
did: self.did.into_static(),
48
+
did_doc: self.did_doc.into_static(),
49
+
handle: self.handle.into_static(),
50
+
handle_is_correct: self.handle_is_correct.into_static(),
51
+
extra_data: self.extra_data.into_static(),
52
+
}
53
+
}
54
+
}
55
+
33
56
impl jacquard_common::types::xrpc::XrpcRequest for DescribeRepo<'_> {
34
57
const NSID: &'static str = "com.atproto.repo.describeRepo";
35
58
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
36
59
const OUTPUT_ENCODING: &'static str = "application/json";
37
60
type Output<'de> = DescribeRepoOutput<'de>;
38
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
61
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
39
62
}
+36
crates/jacquard-api/src/com_atproto/repo/get_record.rs
+36
crates/jacquard-api/src/com_atproto/repo/get_record.rs
···
21
21
>,
22
22
}
23
23
24
+
impl jacquard_common::IntoStatic for GetRecord<'_> {
25
+
type Output = GetRecord<'static>;
26
+
fn into_static(self) -> Self::Output {
27
+
GetRecord {
28
+
cid: self.cid.into_static(),
29
+
collection: self.collection.into_static(),
30
+
repo: self.repo.into_static(),
31
+
rkey: self.rkey.into_static(),
32
+
}
33
+
}
34
+
}
35
+
24
36
#[jacquard_derive::lexicon]
25
37
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
26
38
#[serde(rename_all = "camelCase")]
···
34
46
pub value: jacquard_common::types::value::Data<'a>,
35
47
}
36
48
49
+
impl jacquard_common::IntoStatic for GetRecordOutput<'_> {
50
+
type Output = GetRecordOutput<'static>;
51
+
fn into_static(self) -> Self::Output {
52
+
GetRecordOutput {
53
+
cid: self.cid.into_static(),
54
+
uri: self.uri.into_static(),
55
+
value: self.value.into_static(),
56
+
extra_data: self.extra_data.into_static(),
57
+
}
58
+
}
59
+
}
60
+
37
61
#[jacquard_derive::open_union]
38
62
#[derive(
39
63
serde::Serialize,
···
63
87
Ok(())
64
88
}
65
89
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
90
+
}
91
+
}
92
+
}
93
+
94
+
impl jacquard_common::IntoStatic for GetRecordError<'_> {
95
+
type Output = GetRecordError<'static>;
96
+
fn into_static(self) -> Self::Output {
97
+
match self {
98
+
GetRecordError::RecordNotFound(v) => {
99
+
GetRecordError::RecordNotFound(v.into_static())
100
+
}
101
+
GetRecordError::Unknown(v) => GetRecordError::Unknown(v.into_static()),
66
102
}
67
103
}
68
104
}
+10
-1
crates/jacquard-api/src/com_atproto/repo/import_repo.rs
+10
-1
crates/jacquard-api/src/com_atproto/repo/import_repo.rs
···
9
9
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
10
10
#[serde(rename_all = "camelCase")]
11
11
pub struct ImportRepo<'a> {}
12
+
impl jacquard_common::IntoStatic for ImportRepo<'_> {
13
+
type Output = ImportRepo<'static>;
14
+
fn into_static(self) -> Self::Output {
15
+
ImportRepo {
16
+
extra_data: self.extra_data.into_static(),
17
+
}
18
+
}
19
+
}
20
+
12
21
impl jacquard_common::types::xrpc::XrpcRequest for ImportRepo<'_> {
13
22
const NSID: &'static str = "com.atproto.repo.importRepo";
14
23
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
16
25
);
17
26
const OUTPUT_ENCODING: &'static str = "application/json";
18
27
type Output<'de> = ();
19
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
28
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
20
29
}
+31
-7
crates/jacquard-api/src/com_atproto/repo/list_missing_blobs.rs
+31
-7
crates/jacquard-api/src/com_atproto/repo/list_missing_blobs.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct ListMissingBlobs<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
12
#[serde(borrow)]
13
13
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
14
+
///(default: 500, min: 1, max: 1000)
14
15
#[serde(skip_serializing_if = "std::option::Option::is_none")]
15
16
pub limit: std::option::Option<i64>,
16
17
}
17
18
18
-
impl Default for ListMissingBlobs<'_> {
19
-
fn default() -> Self {
20
-
Self {
21
-
cursor: Default::default(),
22
-
limit: Some(500i64),
19
+
impl jacquard_common::IntoStatic for ListMissingBlobs<'_> {
20
+
type Output = ListMissingBlobs<'static>;
21
+
fn into_static(self) -> Self::Output {
22
+
ListMissingBlobs {
23
+
cursor: self.cursor.into_static(),
24
+
limit: self.limit.into_static(),
23
25
}
24
26
}
25
27
}
···
35
37
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
36
38
}
37
39
40
+
impl jacquard_common::IntoStatic for ListMissingBlobsOutput<'_> {
41
+
type Output = ListMissingBlobsOutput<'static>;
42
+
fn into_static(self) -> Self::Output {
43
+
ListMissingBlobsOutput {
44
+
blobs: self.blobs.into_static(),
45
+
cursor: self.cursor.into_static(),
46
+
extra_data: self.extra_data.into_static(),
47
+
}
48
+
}
49
+
}
50
+
38
51
impl jacquard_common::types::xrpc::XrpcRequest for ListMissingBlobs<'_> {
39
52
const NSID: &'static str = "com.atproto.repo.listMissingBlobs";
40
53
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
41
54
const OUTPUT_ENCODING: &'static str = "application/json";
42
55
type Output<'de> = ListMissingBlobsOutput<'de>;
43
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
56
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
44
57
}
45
58
46
59
#[jacquard_derive::lexicon]
···
51
64
pub cid: jacquard_common::types::string::Cid<'a>,
52
65
#[serde(borrow)]
53
66
pub record_uri: jacquard_common::types::string::AtUri<'a>,
67
+
}
68
+
69
+
impl jacquard_common::IntoStatic for RecordBlob<'_> {
70
+
type Output = RecordBlob<'static>;
71
+
fn into_static(self) -> Self::Output {
72
+
RecordBlob {
73
+
cid: self.cid.into_static(),
74
+
record_uri: self.record_uri.into_static(),
75
+
extra_data: self.extra_data.into_static(),
76
+
}
77
+
}
54
78
}
+35
-10
crates/jacquard-api/src/com_atproto/repo/list_records.rs
+35
-10
crates/jacquard-api/src/com_atproto/repo/list_records.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct ListRecords<'a> {
11
11
#[serde(borrow)]
···
13
13
#[serde(skip_serializing_if = "std::option::Option::is_none")]
14
14
#[serde(borrow)]
15
15
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
16
+
///(default: 50, min: 1, max: 100)
16
17
#[serde(skip_serializing_if = "std::option::Option::is_none")]
17
18
pub limit: std::option::Option<i64>,
18
19
#[serde(borrow)]
···
21
22
pub reverse: std::option::Option<bool>,
22
23
}
23
24
24
-
impl Default for ListRecords<'_> {
25
-
fn default() -> Self {
26
-
Self {
27
-
collection: Default::default(),
28
-
cursor: Default::default(),
29
-
limit: Some(50i64),
30
-
repo: Default::default(),
31
-
reverse: Default::default(),
25
+
impl jacquard_common::IntoStatic for ListRecords<'_> {
26
+
type Output = ListRecords<'static>;
27
+
fn into_static(self) -> Self::Output {
28
+
ListRecords {
29
+
collection: self.collection.into_static(),
30
+
cursor: self.cursor.into_static(),
31
+
limit: self.limit.into_static(),
32
+
repo: self.repo.into_static(),
33
+
reverse: self.reverse.into_static(),
32
34
}
33
35
}
34
36
}
···
44
46
pub records: Vec<jacquard_common::types::value::Data<'a>>,
45
47
}
46
48
49
+
impl jacquard_common::IntoStatic for ListRecordsOutput<'_> {
50
+
type Output = ListRecordsOutput<'static>;
51
+
fn into_static(self) -> Self::Output {
52
+
ListRecordsOutput {
53
+
cursor: self.cursor.into_static(),
54
+
records: self.records.into_static(),
55
+
extra_data: self.extra_data.into_static(),
56
+
}
57
+
}
58
+
}
59
+
47
60
impl jacquard_common::types::xrpc::XrpcRequest for ListRecords<'_> {
48
61
const NSID: &'static str = "com.atproto.repo.listRecords";
49
62
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
50
63
const OUTPUT_ENCODING: &'static str = "application/json";
51
64
type Output<'de> = ListRecordsOutput<'de>;
52
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
65
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
53
66
}
54
67
55
68
#[jacquard_derive::lexicon]
···
62
75
pub uri: jacquard_common::types::string::AtUri<'a>,
63
76
#[serde(borrow)]
64
77
pub value: jacquard_common::types::value::Data<'a>,
78
+
}
79
+
80
+
impl jacquard_common::IntoStatic for Record<'_> {
81
+
type Output = Record<'static>;
82
+
fn into_static(self) -> Self::Output {
83
+
Record {
84
+
cid: self.cid.into_static(),
85
+
uri: self.uri.into_static(),
86
+
value: self.value.into_static(),
87
+
extra_data: self.extra_data.into_static(),
88
+
}
89
+
}
65
90
}
+41
crates/jacquard-api/src/com_atproto/repo/put_record.rs
+41
crates/jacquard-api/src/com_atproto/repo/put_record.rs
···
36
36
pub validate: std::option::Option<bool>,
37
37
}
38
38
39
+
impl jacquard_common::IntoStatic for PutRecord<'_> {
40
+
type Output = PutRecord<'static>;
41
+
fn into_static(self) -> Self::Output {
42
+
PutRecord {
43
+
collection: self.collection.into_static(),
44
+
record: self.record.into_static(),
45
+
repo: self.repo.into_static(),
46
+
rkey: self.rkey.into_static(),
47
+
swap_commit: self.swap_commit.into_static(),
48
+
swap_record: self.swap_record.into_static(),
49
+
validate: self.validate.into_static(),
50
+
extra_data: self.extra_data.into_static(),
51
+
}
52
+
}
53
+
}
54
+
39
55
#[jacquard_derive::lexicon]
40
56
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
41
57
#[serde(rename_all = "camelCase")]
···
52
68
pub validation_status: std::option::Option<jacquard_common::CowStr<'a>>,
53
69
}
54
70
71
+
impl jacquard_common::IntoStatic for PutRecordOutput<'_> {
72
+
type Output = PutRecordOutput<'static>;
73
+
fn into_static(self) -> Self::Output {
74
+
PutRecordOutput {
75
+
cid: self.cid.into_static(),
76
+
commit: self.commit.into_static(),
77
+
uri: self.uri.into_static(),
78
+
validation_status: self.validation_status.into_static(),
79
+
extra_data: self.extra_data.into_static(),
80
+
}
81
+
}
82
+
}
83
+
55
84
#[jacquard_derive::open_union]
56
85
#[derive(
57
86
serde::Serialize,
···
81
110
Ok(())
82
111
}
83
112
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
113
+
}
114
+
}
115
+
}
116
+
117
+
impl jacquard_common::IntoStatic for PutRecordError<'_> {
118
+
type Output = PutRecordError<'static>;
119
+
fn into_static(self) -> Self::Output {
120
+
match self {
121
+
PutRecordError::InvalidSwap(v) => {
122
+
PutRecordError::InvalidSwap(v.into_static())
123
+
}
124
+
PutRecordError::Unknown(v) => PutRecordError::Unknown(v.into_static()),
84
125
}
85
126
}
86
127
}
+11
crates/jacquard-api/src/com_atproto/repo/strong_ref.rs
+11
crates/jacquard-api/src/com_atproto/repo/strong_ref.rs
···
13
13
pub cid: jacquard_common::types::string::Cid<'a>,
14
14
#[serde(borrow)]
15
15
pub uri: jacquard_common::types::string::AtUri<'a>,
16
+
}
17
+
18
+
impl jacquard_common::IntoStatic for StrongRef<'_> {
19
+
type Output = StrongRef<'static>;
20
+
fn into_static(self) -> Self::Output {
21
+
StrongRef {
22
+
cid: self.cid.into_static(),
23
+
uri: self.uri.into_static(),
24
+
extra_data: self.extra_data.into_static(),
25
+
}
26
+
}
16
27
}
+20
-1
crates/jacquard-api/src/com_atproto/repo/upload_blob.rs
+20
-1
crates/jacquard-api/src/com_atproto/repo/upload_blob.rs
···
9
9
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
10
10
#[serde(rename_all = "camelCase")]
11
11
pub struct UploadBlob<'a> {}
12
+
impl jacquard_common::IntoStatic for UploadBlob<'_> {
13
+
type Output = UploadBlob<'static>;
14
+
fn into_static(self) -> Self::Output {
15
+
UploadBlob {
16
+
extra_data: self.extra_data.into_static(),
17
+
}
18
+
}
19
+
}
20
+
12
21
#[jacquard_derive::lexicon]
13
22
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
14
23
#[serde(rename_all = "camelCase")]
···
17
26
pub blob: jacquard_common::types::blob::Blob<'a>,
18
27
}
19
28
29
+
impl jacquard_common::IntoStatic for UploadBlobOutput<'_> {
30
+
type Output = UploadBlobOutput<'static>;
31
+
fn into_static(self) -> Self::Output {
32
+
UploadBlobOutput {
33
+
blob: self.blob.into_static(),
34
+
extra_data: self.extra_data.into_static(),
35
+
}
36
+
}
37
+
}
38
+
20
39
impl jacquard_common::types::xrpc::XrpcRequest for UploadBlob<'_> {
21
40
const NSID: &'static str = "com.atproto.repo.uploadBlob";
22
41
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
24
43
);
25
44
const OUTPUT_ENCODING: &'static str = "application/json";
26
45
type Output<'de> = UploadBlobOutput<'de>;
27
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
46
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
28
47
}
+27
crates/jacquard-api/src/com_atproto/server.rs
+27
crates/jacquard-api/src/com_atproto/server.rs
···
48
48
pub uses: Vec<crate::com_atproto::server::InviteCodeUse<'a>>,
49
49
}
50
50
51
+
impl jacquard_common::IntoStatic for InviteCode<'_> {
52
+
type Output = InviteCode<'static>;
53
+
fn into_static(self) -> Self::Output {
54
+
InviteCode {
55
+
available: self.available.into_static(),
56
+
code: self.code.into_static(),
57
+
created_at: self.created_at.into_static(),
58
+
created_by: self.created_by.into_static(),
59
+
disabled: self.disabled.into_static(),
60
+
for_account: self.for_account.into_static(),
61
+
uses: self.uses.into_static(),
62
+
extra_data: self.extra_data.into_static(),
63
+
}
64
+
}
65
+
}
66
+
51
67
#[jacquard_derive::lexicon]
52
68
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
53
69
#[serde(rename_all = "camelCase")]
···
55
71
pub used_at: jacquard_common::types::string::Datetime,
56
72
#[serde(borrow)]
57
73
pub used_by: jacquard_common::types::string::Did<'a>,
74
+
}
75
+
76
+
impl jacquard_common::IntoStatic for InviteCodeUse<'_> {
77
+
type Output = InviteCodeUse<'static>;
78
+
fn into_static(self) -> Self::Output {
79
+
InviteCodeUse {
80
+
used_at: self.used_at.into_static(),
81
+
used_by: self.used_by.into_static(),
82
+
extra_data: self.extra_data.into_static(),
83
+
}
84
+
}
58
85
}
+1
-1
crates/jacquard-api/src/com_atproto/server/activate_account.rs
+1
-1
crates/jacquard-api/src/com_atproto/server/activate_account.rs
+19
-1
crates/jacquard-api/src/com_atproto/server/check_account_status.rs
+19
-1
crates/jacquard-api/src/com_atproto/server/check_account_status.rs
···
22
22
pub valid_did: bool,
23
23
}
24
24
25
+
impl jacquard_common::IntoStatic for CheckAccountStatusOutput<'_> {
26
+
type Output = CheckAccountStatusOutput<'static>;
27
+
fn into_static(self) -> Self::Output {
28
+
CheckAccountStatusOutput {
29
+
activated: self.activated.into_static(),
30
+
expected_blobs: self.expected_blobs.into_static(),
31
+
imported_blobs: self.imported_blobs.into_static(),
32
+
indexed_records: self.indexed_records.into_static(),
33
+
private_state_values: self.private_state_values.into_static(),
34
+
repo_blocks: self.repo_blocks.into_static(),
35
+
repo_commit: self.repo_commit.into_static(),
36
+
repo_rev: self.repo_rev.into_static(),
37
+
valid_did: self.valid_did.into_static(),
38
+
extra_data: self.extra_data.into_static(),
39
+
}
40
+
}
41
+
}
42
+
25
43
/// XRPC request marker type
26
44
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]
27
45
pub struct CheckAccountStatus;
···
30
48
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
31
49
const OUTPUT_ENCODING: &'static str = "application/json";
32
50
type Output<'de> = CheckAccountStatusOutput<'de>;
33
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
51
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
34
52
}
+32
crates/jacquard-api/src/com_atproto/server/confirm_email.rs
+32
crates/jacquard-api/src/com_atproto/server/confirm_email.rs
···
15
15
pub token: jacquard_common::CowStr<'a>,
16
16
}
17
17
18
+
impl jacquard_common::IntoStatic for ConfirmEmail<'_> {
19
+
type Output = ConfirmEmail<'static>;
20
+
fn into_static(self) -> Self::Output {
21
+
ConfirmEmail {
22
+
email: self.email.into_static(),
23
+
token: self.token.into_static(),
24
+
extra_data: self.extra_data.into_static(),
25
+
}
26
+
}
27
+
}
28
+
18
29
#[jacquard_derive::open_union]
19
30
#[derive(
20
31
serde::Serialize,
···
71
82
Ok(())
72
83
}
73
84
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
85
+
}
86
+
}
87
+
}
88
+
89
+
impl jacquard_common::IntoStatic for ConfirmEmailError<'_> {
90
+
type Output = ConfirmEmailError<'static>;
91
+
fn into_static(self) -> Self::Output {
92
+
match self {
93
+
ConfirmEmailError::AccountNotFound(v) => {
94
+
ConfirmEmailError::AccountNotFound(v.into_static())
95
+
}
96
+
ConfirmEmailError::ExpiredToken(v) => {
97
+
ConfirmEmailError::ExpiredToken(v.into_static())
98
+
}
99
+
ConfirmEmailError::InvalidToken(v) => {
100
+
ConfirmEmailError::InvalidToken(v.into_static())
101
+
}
102
+
ConfirmEmailError::InvalidEmail(v) => {
103
+
ConfirmEmailError::InvalidEmail(v.into_static())
104
+
}
105
+
ConfirmEmailError::Unknown(v) => ConfirmEmailError::Unknown(v.into_static()),
74
106
}
75
107
}
76
108
}
+64
crates/jacquard-api/src/com_atproto/server/create_account.rs
+64
crates/jacquard-api/src/com_atproto/server/create_account.rs
···
42
42
pub verification_phone: std::option::Option<jacquard_common::CowStr<'a>>,
43
43
}
44
44
45
+
impl jacquard_common::IntoStatic for CreateAccount<'_> {
46
+
type Output = CreateAccount<'static>;
47
+
fn into_static(self) -> Self::Output {
48
+
CreateAccount {
49
+
did: self.did.into_static(),
50
+
email: self.email.into_static(),
51
+
handle: self.handle.into_static(),
52
+
invite_code: self.invite_code.into_static(),
53
+
password: self.password.into_static(),
54
+
plc_op: self.plc_op.into_static(),
55
+
recovery_key: self.recovery_key.into_static(),
56
+
verification_code: self.verification_code.into_static(),
57
+
verification_phone: self.verification_phone.into_static(),
58
+
extra_data: self.extra_data.into_static(),
59
+
}
60
+
}
61
+
}
62
+
45
63
#[jacquard_derive::lexicon]
46
64
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
47
65
#[serde(rename_all = "camelCase")]
···
59
77
pub handle: jacquard_common::types::string::Handle<'a>,
60
78
#[serde(borrow)]
61
79
pub refresh_jwt: jacquard_common::CowStr<'a>,
80
+
}
81
+
82
+
impl jacquard_common::IntoStatic for CreateAccountOutput<'_> {
83
+
type Output = CreateAccountOutput<'static>;
84
+
fn into_static(self) -> Self::Output {
85
+
CreateAccountOutput {
86
+
access_jwt: self.access_jwt.into_static(),
87
+
did: self.did.into_static(),
88
+
did_doc: self.did_doc.into_static(),
89
+
handle: self.handle.into_static(),
90
+
refresh_jwt: self.refresh_jwt.into_static(),
91
+
extra_data: self.extra_data.into_static(),
92
+
}
93
+
}
62
94
}
63
95
64
96
#[jacquard_derive::open_union]
···
144
176
Ok(())
145
177
}
146
178
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
179
+
}
180
+
}
181
+
}
182
+
183
+
impl jacquard_common::IntoStatic for CreateAccountError<'_> {
184
+
type Output = CreateAccountError<'static>;
185
+
fn into_static(self) -> Self::Output {
186
+
match self {
187
+
CreateAccountError::InvalidHandle(v) => {
188
+
CreateAccountError::InvalidHandle(v.into_static())
189
+
}
190
+
CreateAccountError::InvalidPassword(v) => {
191
+
CreateAccountError::InvalidPassword(v.into_static())
192
+
}
193
+
CreateAccountError::InvalidInviteCode(v) => {
194
+
CreateAccountError::InvalidInviteCode(v.into_static())
195
+
}
196
+
CreateAccountError::HandleNotAvailable(v) => {
197
+
CreateAccountError::HandleNotAvailable(v.into_static())
198
+
}
199
+
CreateAccountError::UnsupportedDomain(v) => {
200
+
CreateAccountError::UnsupportedDomain(v.into_static())
201
+
}
202
+
CreateAccountError::UnresolvableDid(v) => {
203
+
CreateAccountError::UnresolvableDid(v.into_static())
204
+
}
205
+
CreateAccountError::IncompatibleDidDoc(v) => {
206
+
CreateAccountError::IncompatibleDidDoc(v.into_static())
207
+
}
208
+
CreateAccountError::Unknown(v) => {
209
+
CreateAccountError::Unknown(v.into_static())
210
+
}
147
211
}
148
212
}
149
213
}
+48
crates/jacquard-api/src/com_atproto/server/create_app_password.rs
+48
crates/jacquard-api/src/com_atproto/server/create_app_password.rs
···
18
18
pub privileged: std::option::Option<bool>,
19
19
}
20
20
21
+
impl jacquard_common::IntoStatic for AppPassword<'_> {
22
+
type Output = AppPassword<'static>;
23
+
fn into_static(self) -> Self::Output {
24
+
AppPassword {
25
+
created_at: self.created_at.into_static(),
26
+
name: self.name.into_static(),
27
+
password: self.password.into_static(),
28
+
privileged: self.privileged.into_static(),
29
+
extra_data: self.extra_data.into_static(),
30
+
}
31
+
}
32
+
}
33
+
21
34
#[jacquard_derive::lexicon]
22
35
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
23
36
#[serde(rename_all = "camelCase")]
···
28
41
///If an app password has 'privileged' access to possibly sensitive account state. Meant for use with trusted clients.
29
42
#[serde(skip_serializing_if = "std::option::Option::is_none")]
30
43
pub privileged: std::option::Option<bool>,
44
+
}
45
+
46
+
impl jacquard_common::IntoStatic for CreateAppPassword<'_> {
47
+
type Output = CreateAppPassword<'static>;
48
+
fn into_static(self) -> Self::Output {
49
+
CreateAppPassword {
50
+
name: self.name.into_static(),
51
+
privileged: self.privileged.into_static(),
52
+
extra_data: self.extra_data.into_static(),
53
+
}
54
+
}
31
55
}
32
56
33
57
#[jacquard_derive::lexicon]
···
39
63
pub value: jacquard_common::types::value::Data<'a>,
40
64
}
41
65
66
+
impl jacquard_common::IntoStatic for CreateAppPasswordOutput<'_> {
67
+
type Output = CreateAppPasswordOutput<'static>;
68
+
fn into_static(self) -> Self::Output {
69
+
CreateAppPasswordOutput {
70
+
value: self.value.into_static(),
71
+
extra_data: self.extra_data.into_static(),
72
+
}
73
+
}
74
+
}
75
+
42
76
#[jacquard_derive::open_union]
43
77
#[derive(
44
78
serde::Serialize,
···
68
102
Ok(())
69
103
}
70
104
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
105
+
}
106
+
}
107
+
}
108
+
109
+
impl jacquard_common::IntoStatic for CreateAppPasswordError<'_> {
110
+
type Output = CreateAppPasswordError<'static>;
111
+
fn into_static(self) -> Self::Output {
112
+
match self {
113
+
CreateAppPasswordError::AccountTakedown(v) => {
114
+
CreateAppPasswordError::AccountTakedown(v.into_static())
115
+
}
116
+
CreateAppPasswordError::Unknown(v) => {
117
+
CreateAppPasswordError::Unknown(v.into_static())
118
+
}
71
119
}
72
120
}
73
121
}
+22
-1
crates/jacquard-api/src/com_atproto/server/create_invite_code.rs
+22
-1
crates/jacquard-api/src/com_atproto/server/create_invite_code.rs
···
15
15
pub use_count: i64,
16
16
}
17
17
18
+
impl jacquard_common::IntoStatic for CreateInviteCode<'_> {
19
+
type Output = CreateInviteCode<'static>;
20
+
fn into_static(self) -> Self::Output {
21
+
CreateInviteCode {
22
+
for_account: self.for_account.into_static(),
23
+
use_count: self.use_count.into_static(),
24
+
extra_data: self.extra_data.into_static(),
25
+
}
26
+
}
27
+
}
28
+
18
29
#[jacquard_derive::lexicon]
19
30
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
20
31
#[serde(rename_all = "camelCase")]
···
23
34
pub code: jacquard_common::CowStr<'a>,
24
35
}
25
36
37
+
impl jacquard_common::IntoStatic for CreateInviteCodeOutput<'_> {
38
+
type Output = CreateInviteCodeOutput<'static>;
39
+
fn into_static(self) -> Self::Output {
40
+
CreateInviteCodeOutput {
41
+
code: self.code.into_static(),
42
+
extra_data: self.extra_data.into_static(),
43
+
}
44
+
}
45
+
}
46
+
26
47
impl jacquard_common::types::xrpc::XrpcRequest for CreateInviteCode<'_> {
27
48
const NSID: &'static str = "com.atproto.server.createInviteCode";
28
49
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
30
51
);
31
52
const OUTPUT_ENCODING: &'static str = "application/json";
32
53
type Output<'de> = CreateInviteCodeOutput<'de>;
33
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
54
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
34
55
}
+34
-1
crates/jacquard-api/src/com_atproto/server/create_invite_codes.rs
+34
-1
crates/jacquard-api/src/com_atproto/server/create_invite_codes.rs
···
15
15
pub codes: Vec<jacquard_common::CowStr<'a>>,
16
16
}
17
17
18
+
impl jacquard_common::IntoStatic for AccountCodes<'_> {
19
+
type Output = AccountCodes<'static>;
20
+
fn into_static(self) -> Self::Output {
21
+
AccountCodes {
22
+
account: self.account.into_static(),
23
+
codes: self.codes.into_static(),
24
+
extra_data: self.extra_data.into_static(),
25
+
}
26
+
}
27
+
}
28
+
18
29
#[jacquard_derive::lexicon]
19
30
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
20
31
#[serde(rename_all = "camelCase")]
···
26
37
pub use_count: i64,
27
38
}
28
39
40
+
impl jacquard_common::IntoStatic for CreateInviteCodes<'_> {
41
+
type Output = CreateInviteCodes<'static>;
42
+
fn into_static(self) -> Self::Output {
43
+
CreateInviteCodes {
44
+
code_count: self.code_count.into_static(),
45
+
for_accounts: self.for_accounts.into_static(),
46
+
use_count: self.use_count.into_static(),
47
+
extra_data: self.extra_data.into_static(),
48
+
}
49
+
}
50
+
}
51
+
29
52
#[jacquard_derive::lexicon]
30
53
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
31
54
#[serde(rename_all = "camelCase")]
···
34
57
pub codes: Vec<jacquard_common::types::value::Data<'a>>,
35
58
}
36
59
60
+
impl jacquard_common::IntoStatic for CreateInviteCodesOutput<'_> {
61
+
type Output = CreateInviteCodesOutput<'static>;
62
+
fn into_static(self) -> Self::Output {
63
+
CreateInviteCodesOutput {
64
+
codes: self.codes.into_static(),
65
+
extra_data: self.extra_data.into_static(),
66
+
}
67
+
}
68
+
}
69
+
37
70
impl jacquard_common::types::xrpc::XrpcRequest for CreateInviteCodes<'_> {
38
71
const NSID: &'static str = "com.atproto.server.createInviteCodes";
39
72
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
41
74
);
42
75
const OUTPUT_ENCODING: &'static str = "application/json";
43
76
type Output<'de> = CreateInviteCodesOutput<'de>;
44
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
77
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
45
78
}
+49
crates/jacquard-api/src/com_atproto/server/create_session.rs
+49
crates/jacquard-api/src/com_atproto/server/create_session.rs
···
22
22
pub password: jacquard_common::CowStr<'a>,
23
23
}
24
24
25
+
impl jacquard_common::IntoStatic for CreateSession<'_> {
26
+
type Output = CreateSession<'static>;
27
+
fn into_static(self) -> Self::Output {
28
+
CreateSession {
29
+
allow_takendown: self.allow_takendown.into_static(),
30
+
auth_factor_token: self.auth_factor_token.into_static(),
31
+
identifier: self.identifier.into_static(),
32
+
password: self.password.into_static(),
33
+
extra_data: self.extra_data.into_static(),
34
+
}
35
+
}
36
+
}
37
+
25
38
#[jacquard_derive::lexicon]
26
39
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
27
40
#[serde(rename_all = "camelCase")]
···
52
65
pub status: std::option::Option<jacquard_common::CowStr<'a>>,
53
66
}
54
67
68
+
impl jacquard_common::IntoStatic for CreateSessionOutput<'_> {
69
+
type Output = CreateSessionOutput<'static>;
70
+
fn into_static(self) -> Self::Output {
71
+
CreateSessionOutput {
72
+
access_jwt: self.access_jwt.into_static(),
73
+
active: self.active.into_static(),
74
+
did: self.did.into_static(),
75
+
did_doc: self.did_doc.into_static(),
76
+
email: self.email.into_static(),
77
+
email_auth_factor: self.email_auth_factor.into_static(),
78
+
email_confirmed: self.email_confirmed.into_static(),
79
+
handle: self.handle.into_static(),
80
+
refresh_jwt: self.refresh_jwt.into_static(),
81
+
status: self.status.into_static(),
82
+
extra_data: self.extra_data.into_static(),
83
+
}
84
+
}
85
+
}
86
+
55
87
#[jacquard_derive::open_union]
56
88
#[derive(
57
89
serde::Serialize,
···
90
122
Ok(())
91
123
}
92
124
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
125
+
}
126
+
}
127
+
}
128
+
129
+
impl jacquard_common::IntoStatic for CreateSessionError<'_> {
130
+
type Output = CreateSessionError<'static>;
131
+
fn into_static(self) -> Self::Output {
132
+
match self {
133
+
CreateSessionError::AccountTakedown(v) => {
134
+
CreateSessionError::AccountTakedown(v.into_static())
135
+
}
136
+
CreateSessionError::AuthFactorTokenRequired(v) => {
137
+
CreateSessionError::AuthFactorTokenRequired(v.into_static())
138
+
}
139
+
CreateSessionError::Unknown(v) => {
140
+
CreateSessionError::Unknown(v.into_static())
141
+
}
93
142
}
94
143
}
95
144
}
+11
-1
crates/jacquard-api/src/com_atproto/server/deactivate_account.rs
+11
-1
crates/jacquard-api/src/com_atproto/server/deactivate_account.rs
···
14
14
pub delete_after: std::option::Option<jacquard_common::types::string::Datetime>,
15
15
}
16
16
17
+
impl jacquard_common::IntoStatic for DeactivateAccount<'_> {
18
+
type Output = DeactivateAccount<'static>;
19
+
fn into_static(self) -> Self::Output {
20
+
DeactivateAccount {
21
+
delete_after: self.delete_after.into_static(),
22
+
extra_data: self.extra_data.into_static(),
23
+
}
24
+
}
25
+
}
26
+
17
27
impl jacquard_common::types::xrpc::XrpcRequest for DeactivateAccount<'_> {
18
28
const NSID: &'static str = "com.atproto.server.deactivateAccount";
19
29
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
21
31
);
22
32
const OUTPUT_ENCODING: &'static str = "application/json";
23
33
type Output<'de> = ();
24
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
34
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
25
35
}
+29
crates/jacquard-api/src/com_atproto/server/delete_account.rs
+29
crates/jacquard-api/src/com_atproto/server/delete_account.rs
···
17
17
pub token: jacquard_common::CowStr<'a>,
18
18
}
19
19
20
+
impl jacquard_common::IntoStatic for DeleteAccount<'_> {
21
+
type Output = DeleteAccount<'static>;
22
+
fn into_static(self) -> Self::Output {
23
+
DeleteAccount {
24
+
did: self.did.into_static(),
25
+
password: self.password.into_static(),
26
+
token: self.token.into_static(),
27
+
extra_data: self.extra_data.into_static(),
28
+
}
29
+
}
30
+
}
31
+
20
32
#[jacquard_derive::open_union]
21
33
#[derive(
22
34
serde::Serialize,
···
55
67
Ok(())
56
68
}
57
69
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
70
+
}
71
+
}
72
+
}
73
+
74
+
impl jacquard_common::IntoStatic for DeleteAccountError<'_> {
75
+
type Output = DeleteAccountError<'static>;
76
+
fn into_static(self) -> Self::Output {
77
+
match self {
78
+
DeleteAccountError::ExpiredToken(v) => {
79
+
DeleteAccountError::ExpiredToken(v.into_static())
80
+
}
81
+
DeleteAccountError::InvalidToken(v) => {
82
+
DeleteAccountError::InvalidToken(v.into_static())
83
+
}
84
+
DeleteAccountError::Unknown(v) => {
85
+
DeleteAccountError::Unknown(v.into_static())
86
+
}
58
87
}
59
88
}
60
89
}
+1
-1
crates/jacquard-api/src/com_atproto/server/delete_session.rs
+1
-1
crates/jacquard-api/src/com_atproto/server/delete_session.rs
+37
-1
crates/jacquard-api/src/com_atproto/server/describe_server.rs
+37
-1
crates/jacquard-api/src/com_atproto/server/describe_server.rs
···
14
14
pub email: std::option::Option<jacquard_common::CowStr<'a>>,
15
15
}
16
16
17
+
impl jacquard_common::IntoStatic for Contact<'_> {
18
+
type Output = Contact<'static>;
19
+
fn into_static(self) -> Self::Output {
20
+
Contact {
21
+
email: self.email.into_static(),
22
+
extra_data: self.extra_data.into_static(),
23
+
}
24
+
}
25
+
}
26
+
17
27
#[jacquard_derive::lexicon]
18
28
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
19
29
#[serde(rename_all = "camelCase")]
···
26
36
pub terms_of_service: std::option::Option<jacquard_common::types::string::Uri<'a>>,
27
37
}
28
38
39
+
impl jacquard_common::IntoStatic for Links<'_> {
40
+
type Output = Links<'static>;
41
+
fn into_static(self) -> Self::Output {
42
+
Links {
43
+
privacy_policy: self.privacy_policy.into_static(),
44
+
terms_of_service: self.terms_of_service.into_static(),
45
+
extra_data: self.extra_data.into_static(),
46
+
}
47
+
}
48
+
}
49
+
29
50
#[jacquard_derive::lexicon]
30
51
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
31
52
#[serde(rename_all = "camelCase")]
···
51
72
pub phone_verification_required: std::option::Option<bool>,
52
73
}
53
74
75
+
impl jacquard_common::IntoStatic for DescribeServerOutput<'_> {
76
+
type Output = DescribeServerOutput<'static>;
77
+
fn into_static(self) -> Self::Output {
78
+
DescribeServerOutput {
79
+
available_user_domains: self.available_user_domains.into_static(),
80
+
contact: self.contact.into_static(),
81
+
did: self.did.into_static(),
82
+
invite_code_required: self.invite_code_required.into_static(),
83
+
links: self.links.into_static(),
84
+
phone_verification_required: self.phone_verification_required.into_static(),
85
+
extra_data: self.extra_data.into_static(),
86
+
}
87
+
}
88
+
}
89
+
54
90
/// XRPC request marker type
55
91
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]
56
92
pub struct DescribeServer;
···
59
95
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
60
96
const OUTPUT_ENCODING: &'static str = "application/json";
61
97
type Output<'de> = DescribeServerOutput<'de>;
62
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
98
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
63
99
}
+34
-1
crates/jacquard-api/src/com_atproto/server/get_account_invite_codes.rs
+34
-1
crates/jacquard-api/src/com_atproto/server/get_account_invite_codes.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetAccountInviteCodes {
11
+
///(default: true)
11
12
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
13
pub create_available: std::option::Option<bool>,
14
+
///(default: true)
13
15
#[serde(skip_serializing_if = "std::option::Option::is_none")]
14
16
pub include_used: std::option::Option<bool>,
15
17
}
16
18
19
+
impl jacquard_common::IntoStatic for GetAccountInviteCodes {
20
+
type Output = GetAccountInviteCodes;
21
+
fn into_static(self) -> Self::Output {
22
+
self
23
+
}
24
+
}
25
+
17
26
#[jacquard_derive::lexicon]
18
27
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
19
28
#[serde(rename_all = "camelCase")]
···
22
31
pub codes: Vec<crate::com_atproto::server::InviteCode<'a>>,
23
32
}
24
33
34
+
impl jacquard_common::IntoStatic for GetAccountInviteCodesOutput<'_> {
35
+
type Output = GetAccountInviteCodesOutput<'static>;
36
+
fn into_static(self) -> Self::Output {
37
+
GetAccountInviteCodesOutput {
38
+
codes: self.codes.into_static(),
39
+
extra_data: self.extra_data.into_static(),
40
+
}
41
+
}
42
+
}
43
+
25
44
#[jacquard_derive::open_union]
26
45
#[derive(
27
46
serde::Serialize,
···
51
70
Ok(())
52
71
}
53
72
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
73
+
}
74
+
}
75
+
}
76
+
77
+
impl jacquard_common::IntoStatic for GetAccountInviteCodesError<'_> {
78
+
type Output = GetAccountInviteCodesError<'static>;
79
+
fn into_static(self) -> Self::Output {
80
+
match self {
81
+
GetAccountInviteCodesError::DuplicateCreate(v) => {
82
+
GetAccountInviteCodesError::DuplicateCreate(v.into_static())
83
+
}
84
+
GetAccountInviteCodesError::Unknown(v) => {
85
+
GetAccountInviteCodesError::Unknown(v.into_static())
86
+
}
54
87
}
55
88
}
56
89
}
+35
crates/jacquard-api/src/com_atproto/server/get_service_auth.rs
+35
crates/jacquard-api/src/com_atproto/server/get_service_auth.rs
···
17
17
pub lxm: std::option::Option<jacquard_common::types::string::Nsid<'a>>,
18
18
}
19
19
20
+
impl jacquard_common::IntoStatic for GetServiceAuth<'_> {
21
+
type Output = GetServiceAuth<'static>;
22
+
fn into_static(self) -> Self::Output {
23
+
GetServiceAuth {
24
+
aud: self.aud.into_static(),
25
+
exp: self.exp.into_static(),
26
+
lxm: self.lxm.into_static(),
27
+
}
28
+
}
29
+
}
30
+
20
31
#[jacquard_derive::lexicon]
21
32
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
22
33
#[serde(rename_all = "camelCase")]
···
25
36
pub token: jacquard_common::CowStr<'a>,
26
37
}
27
38
39
+
impl jacquard_common::IntoStatic for GetServiceAuthOutput<'_> {
40
+
type Output = GetServiceAuthOutput<'static>;
41
+
fn into_static(self) -> Self::Output {
42
+
GetServiceAuthOutput {
43
+
token: self.token.into_static(),
44
+
extra_data: self.extra_data.into_static(),
45
+
}
46
+
}
47
+
}
48
+
28
49
#[jacquard_derive::open_union]
29
50
#[derive(
30
51
serde::Serialize,
···
55
76
Ok(())
56
77
}
57
78
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
79
+
}
80
+
}
81
+
}
82
+
83
+
impl jacquard_common::IntoStatic for GetServiceAuthError<'_> {
84
+
type Output = GetServiceAuthError<'static>;
85
+
fn into_static(self) -> Self::Output {
86
+
match self {
87
+
GetServiceAuthError::BadExpiration(v) => {
88
+
GetServiceAuthError::BadExpiration(v.into_static())
89
+
}
90
+
GetServiceAuthError::Unknown(v) => {
91
+
GetServiceAuthError::Unknown(v.into_static())
92
+
}
58
93
}
59
94
}
60
95
}
+18
-1
crates/jacquard-api/src/com_atproto/server/get_session.rs
+18
-1
crates/jacquard-api/src/com_atproto/server/get_session.rs
···
31
31
pub status: std::option::Option<jacquard_common::CowStr<'a>>,
32
32
}
33
33
34
+
impl jacquard_common::IntoStatic for GetSessionOutput<'_> {
35
+
type Output = GetSessionOutput<'static>;
36
+
fn into_static(self) -> Self::Output {
37
+
GetSessionOutput {
38
+
active: self.active.into_static(),
39
+
did: self.did.into_static(),
40
+
did_doc: self.did_doc.into_static(),
41
+
email: self.email.into_static(),
42
+
email_auth_factor: self.email_auth_factor.into_static(),
43
+
email_confirmed: self.email_confirmed.into_static(),
44
+
handle: self.handle.into_static(),
45
+
status: self.status.into_static(),
46
+
extra_data: self.extra_data.into_static(),
47
+
}
48
+
}
49
+
}
50
+
34
51
/// XRPC request marker type
35
52
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]
36
53
pub struct GetSession;
···
39
56
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
40
57
const OUTPUT_ENCODING: &'static str = "application/json";
41
58
type Output<'de> = GetSessionOutput<'de>;
42
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
59
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
43
60
}
+36
crates/jacquard-api/src/com_atproto/server/list_app_passwords.rs
+36
crates/jacquard-api/src/com_atproto/server/list_app_passwords.rs
···
16
16
pub privileged: std::option::Option<bool>,
17
17
}
18
18
19
+
impl jacquard_common::IntoStatic for AppPassword<'_> {
20
+
type Output = AppPassword<'static>;
21
+
fn into_static(self) -> Self::Output {
22
+
AppPassword {
23
+
created_at: self.created_at.into_static(),
24
+
name: self.name.into_static(),
25
+
privileged: self.privileged.into_static(),
26
+
extra_data: self.extra_data.into_static(),
27
+
}
28
+
}
29
+
}
30
+
19
31
#[jacquard_derive::lexicon]
20
32
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
21
33
#[serde(rename_all = "camelCase")]
···
24
36
pub passwords: Vec<jacquard_common::types::value::Data<'a>>,
25
37
}
26
38
39
+
impl jacquard_common::IntoStatic for ListAppPasswordsOutput<'_> {
40
+
type Output = ListAppPasswordsOutput<'static>;
41
+
fn into_static(self) -> Self::Output {
42
+
ListAppPasswordsOutput {
43
+
passwords: self.passwords.into_static(),
44
+
extra_data: self.extra_data.into_static(),
45
+
}
46
+
}
47
+
}
48
+
27
49
#[jacquard_derive::open_union]
28
50
#[derive(
29
51
serde::Serialize,
···
53
75
Ok(())
54
76
}
55
77
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
78
+
}
79
+
}
80
+
}
81
+
82
+
impl jacquard_common::IntoStatic for ListAppPasswordsError<'_> {
83
+
type Output = ListAppPasswordsError<'static>;
84
+
fn into_static(self) -> Self::Output {
85
+
match self {
86
+
ListAppPasswordsError::AccountTakedown(v) => {
87
+
ListAppPasswordsError::AccountTakedown(v.into_static())
88
+
}
89
+
ListAppPasswordsError::Unknown(v) => {
90
+
ListAppPasswordsError::Unknown(v.into_static())
91
+
}
56
92
}
57
93
}
58
94
}
+30
crates/jacquard-api/src/com_atproto/server/refresh_session.rs
+30
crates/jacquard-api/src/com_atproto/server/refresh_session.rs
···
28
28
pub status: std::option::Option<jacquard_common::CowStr<'a>>,
29
29
}
30
30
31
+
impl jacquard_common::IntoStatic for RefreshSessionOutput<'_> {
32
+
type Output = RefreshSessionOutput<'static>;
33
+
fn into_static(self) -> Self::Output {
34
+
RefreshSessionOutput {
35
+
access_jwt: self.access_jwt.into_static(),
36
+
active: self.active.into_static(),
37
+
did: self.did.into_static(),
38
+
did_doc: self.did_doc.into_static(),
39
+
handle: self.handle.into_static(),
40
+
refresh_jwt: self.refresh_jwt.into_static(),
41
+
status: self.status.into_static(),
42
+
extra_data: self.extra_data.into_static(),
43
+
}
44
+
}
45
+
}
46
+
31
47
#[jacquard_derive::open_union]
32
48
#[derive(
33
49
serde::Serialize,
···
57
73
Ok(())
58
74
}
59
75
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
76
+
}
77
+
}
78
+
}
79
+
80
+
impl jacquard_common::IntoStatic for RefreshSessionError<'_> {
81
+
type Output = RefreshSessionError<'static>;
82
+
fn into_static(self) -> Self::Output {
83
+
match self {
84
+
RefreshSessionError::AccountTakedown(v) => {
85
+
RefreshSessionError::AccountTakedown(v.into_static())
86
+
}
87
+
RefreshSessionError::Unknown(v) => {
88
+
RefreshSessionError::Unknown(v.into_static())
89
+
}
60
90
}
61
91
}
62
92
}
+1
-1
crates/jacquard-api/src/com_atproto/server/request_account_delete.rs
+1
-1
crates/jacquard-api/src/com_atproto/server/request_account_delete.rs
+1
-1
crates/jacquard-api/src/com_atproto/server/request_email_confirmation.rs
+1
-1
crates/jacquard-api/src/com_atproto/server/request_email_confirmation.rs
+11
-1
crates/jacquard-api/src/com_atproto/server/request_email_update.rs
+11
-1
crates/jacquard-api/src/com_atproto/server/request_email_update.rs
···
12
12
pub token_required: bool,
13
13
}
14
14
15
+
impl jacquard_common::IntoStatic for RequestEmailUpdateOutput<'_> {
16
+
type Output = RequestEmailUpdateOutput<'static>;
17
+
fn into_static(self) -> Self::Output {
18
+
RequestEmailUpdateOutput {
19
+
token_required: self.token_required.into_static(),
20
+
extra_data: self.extra_data.into_static(),
21
+
}
22
+
}
23
+
}
24
+
15
25
/// XRPC request marker type
16
26
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]
17
27
pub struct RequestEmailUpdate;
···
22
32
);
23
33
const OUTPUT_ENCODING: &'static str = "application/json";
24
34
type Output<'de> = RequestEmailUpdateOutput<'de>;
25
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
35
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
26
36
}
+11
-1
crates/jacquard-api/src/com_atproto/server/request_password_reset.rs
+11
-1
crates/jacquard-api/src/com_atproto/server/request_password_reset.rs
···
13
13
pub email: jacquard_common::CowStr<'a>,
14
14
}
15
15
16
+
impl jacquard_common::IntoStatic for RequestPasswordReset<'_> {
17
+
type Output = RequestPasswordReset<'static>;
18
+
fn into_static(self) -> Self::Output {
19
+
RequestPasswordReset {
20
+
email: self.email.into_static(),
21
+
extra_data: self.extra_data.into_static(),
22
+
}
23
+
}
24
+
}
25
+
16
26
impl jacquard_common::types::xrpc::XrpcRequest for RequestPasswordReset<'_> {
17
27
const NSID: &'static str = "com.atproto.server.requestPasswordReset";
18
28
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
20
30
);
21
31
const OUTPUT_ENCODING: &'static str = "application/json";
22
32
type Output<'de> = ();
23
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
33
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
24
34
}
+21
-1
crates/jacquard-api/src/com_atproto/server/reserve_signing_key.rs
+21
-1
crates/jacquard-api/src/com_atproto/server/reserve_signing_key.rs
···
15
15
pub did: std::option::Option<jacquard_common::types::string::Did<'a>>,
16
16
}
17
17
18
+
impl jacquard_common::IntoStatic for ReserveSigningKey<'_> {
19
+
type Output = ReserveSigningKey<'static>;
20
+
fn into_static(self) -> Self::Output {
21
+
ReserveSigningKey {
22
+
did: self.did.into_static(),
23
+
extra_data: self.extra_data.into_static(),
24
+
}
25
+
}
26
+
}
27
+
18
28
#[jacquard_derive::lexicon]
19
29
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
20
30
#[serde(rename_all = "camelCase")]
···
24
34
pub signing_key: jacquard_common::CowStr<'a>,
25
35
}
26
36
37
+
impl jacquard_common::IntoStatic for ReserveSigningKeyOutput<'_> {
38
+
type Output = ReserveSigningKeyOutput<'static>;
39
+
fn into_static(self) -> Self::Output {
40
+
ReserveSigningKeyOutput {
41
+
signing_key: self.signing_key.into_static(),
42
+
extra_data: self.extra_data.into_static(),
43
+
}
44
+
}
45
+
}
46
+
27
47
impl jacquard_common::types::xrpc::XrpcRequest for ReserveSigningKey<'_> {
28
48
const NSID: &'static str = "com.atproto.server.reserveSigningKey";
29
49
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
31
51
);
32
52
const OUTPUT_ENCODING: &'static str = "application/json";
33
53
type Output<'de> = ReserveSigningKeyOutput<'de>;
34
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
54
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
35
55
}
+28
crates/jacquard-api/src/com_atproto/server/reset_password.rs
+28
crates/jacquard-api/src/com_atproto/server/reset_password.rs
···
15
15
pub token: jacquard_common::CowStr<'a>,
16
16
}
17
17
18
+
impl jacquard_common::IntoStatic for ResetPassword<'_> {
19
+
type Output = ResetPassword<'static>;
20
+
fn into_static(self) -> Self::Output {
21
+
ResetPassword {
22
+
password: self.password.into_static(),
23
+
token: self.token.into_static(),
24
+
extra_data: self.extra_data.into_static(),
25
+
}
26
+
}
27
+
}
28
+
18
29
#[jacquard_derive::open_union]
19
30
#[derive(
20
31
serde::Serialize,
···
53
64
Ok(())
54
65
}
55
66
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
67
+
}
68
+
}
69
+
}
70
+
71
+
impl jacquard_common::IntoStatic for ResetPasswordError<'_> {
72
+
type Output = ResetPasswordError<'static>;
73
+
fn into_static(self) -> Self::Output {
74
+
match self {
75
+
ResetPasswordError::ExpiredToken(v) => {
76
+
ResetPasswordError::ExpiredToken(v.into_static())
77
+
}
78
+
ResetPasswordError::InvalidToken(v) => {
79
+
ResetPasswordError::InvalidToken(v.into_static())
80
+
}
81
+
ResetPasswordError::Unknown(v) => {
82
+
ResetPasswordError::Unknown(v.into_static())
83
+
}
56
84
}
57
85
}
58
86
}
+11
-1
crates/jacquard-api/src/com_atproto/server/revoke_app_password.rs
+11
-1
crates/jacquard-api/src/com_atproto/server/revoke_app_password.rs
···
13
13
pub name: jacquard_common::CowStr<'a>,
14
14
}
15
15
16
+
impl jacquard_common::IntoStatic for RevokeAppPassword<'_> {
17
+
type Output = RevokeAppPassword<'static>;
18
+
fn into_static(self) -> Self::Output {
19
+
RevokeAppPassword {
20
+
name: self.name.into_static(),
21
+
extra_data: self.extra_data.into_static(),
22
+
}
23
+
}
24
+
}
25
+
16
26
impl jacquard_common::types::xrpc::XrpcRequest for RevokeAppPassword<'_> {
17
27
const NSID: &'static str = "com.atproto.server.revokeAppPassword";
18
28
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
20
30
);
21
31
const OUTPUT_ENCODING: &'static str = "application/json";
22
32
type Output<'de> = ();
23
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
33
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
24
34
}
+30
crates/jacquard-api/src/com_atproto/server/update_email.rs
+30
crates/jacquard-api/src/com_atproto/server/update_email.rs
···
19
19
pub token: std::option::Option<jacquard_common::CowStr<'a>>,
20
20
}
21
21
22
+
impl jacquard_common::IntoStatic for UpdateEmail<'_> {
23
+
type Output = UpdateEmail<'static>;
24
+
fn into_static(self) -> Self::Output {
25
+
UpdateEmail {
26
+
email: self.email.into_static(),
27
+
email_auth_factor: self.email_auth_factor.into_static(),
28
+
token: self.token.into_static(),
29
+
extra_data: self.extra_data.into_static(),
30
+
}
31
+
}
32
+
}
33
+
22
34
#[jacquard_derive::open_union]
23
35
#[derive(
24
36
serde::Serialize,
···
66
78
Ok(())
67
79
}
68
80
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
81
+
}
82
+
}
83
+
}
84
+
85
+
impl jacquard_common::IntoStatic for UpdateEmailError<'_> {
86
+
type Output = UpdateEmailError<'static>;
87
+
fn into_static(self) -> Self::Output {
88
+
match self {
89
+
UpdateEmailError::ExpiredToken(v) => {
90
+
UpdateEmailError::ExpiredToken(v.into_static())
91
+
}
92
+
UpdateEmailError::InvalidToken(v) => {
93
+
UpdateEmailError::InvalidToken(v.into_static())
94
+
}
95
+
UpdateEmailError::TokenRequired(v) => {
96
+
UpdateEmailError::TokenRequired(v.into_static())
97
+
}
98
+
UpdateEmailError::Unknown(v) => UpdateEmailError::Unknown(v.into_static()),
69
99
}
70
100
}
71
101
}
+14
crates/jacquard-api/src/com_atproto/sync.rs
+14
crates/jacquard-api/src/com_atproto/sync.rs
···
97
97
let s = <&'de str>::deserialize(deserializer)?;
98
98
Ok(Self::from(s))
99
99
}
100
+
}
101
+
102
+
impl jacquard_common::IntoStatic for HostStatus<'_> {
103
+
type Output = HostStatus<'static>;
104
+
fn into_static(self) -> Self::Output {
105
+
match self {
106
+
HostStatus::Active => HostStatus::Active,
107
+
HostStatus::Idle => HostStatus::Idle,
108
+
HostStatus::Offline => HostStatus::Offline,
109
+
HostStatus::Throttled => HostStatus::Throttled,
110
+
HostStatus::Banned => HostStatus::Banned,
111
+
HostStatus::Other(v) => HostStatus::Other(v.into_static()),
112
+
}
113
+
}
100
114
}
+39
crates/jacquard-api/src/com_atproto/sync/get_blob.rs
+39
crates/jacquard-api/src/com_atproto/sync/get_blob.rs
···
14
14
pub did: jacquard_common::types::string::Did<'a>,
15
15
}
16
16
17
+
impl jacquard_common::IntoStatic for GetBlob<'_> {
18
+
type Output = GetBlob<'static>;
19
+
fn into_static(self) -> Self::Output {
20
+
GetBlob {
21
+
cid: self.cid.into_static(),
22
+
did: self.did.into_static(),
23
+
}
24
+
}
25
+
}
26
+
17
27
#[jacquard_derive::lexicon]
18
28
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
19
29
#[serde(rename_all = "camelCase")]
20
30
pub struct GetBlobOutput<'a> {}
31
+
impl jacquard_common::IntoStatic for GetBlobOutput<'_> {
32
+
type Output = GetBlobOutput<'static>;
33
+
fn into_static(self) -> Self::Output {
34
+
GetBlobOutput {
35
+
extra_data: self.extra_data.into_static(),
36
+
}
37
+
}
38
+
}
39
+
21
40
#[jacquard_derive::open_union]
22
41
#[derive(
23
42
serde::Serialize,
···
83
102
Ok(())
84
103
}
85
104
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
105
+
}
106
+
}
107
+
}
108
+
109
+
impl jacquard_common::IntoStatic for GetBlobError<'_> {
110
+
type Output = GetBlobError<'static>;
111
+
fn into_static(self) -> Self::Output {
112
+
match self {
113
+
GetBlobError::BlobNotFound(v) => GetBlobError::BlobNotFound(v.into_static()),
114
+
GetBlobError::RepoNotFound(v) => GetBlobError::RepoNotFound(v.into_static()),
115
+
GetBlobError::RepoTakendown(v) => {
116
+
GetBlobError::RepoTakendown(v.into_static())
117
+
}
118
+
GetBlobError::RepoSuspended(v) => {
119
+
GetBlobError::RepoSuspended(v.into_static())
120
+
}
121
+
GetBlobError::RepoDeactivated(v) => {
122
+
GetBlobError::RepoDeactivated(v.into_static())
123
+
}
124
+
GetBlobError::Unknown(v) => GetBlobError::Unknown(v.into_static()),
86
125
}
87
126
}
88
127
}
+43
crates/jacquard-api/src/com_atproto/sync/get_blocks.rs
+43
crates/jacquard-api/src/com_atproto/sync/get_blocks.rs
···
14
14
pub did: jacquard_common::types::string::Did<'a>,
15
15
}
16
16
17
+
impl jacquard_common::IntoStatic for GetBlocks<'_> {
18
+
type Output = GetBlocks<'static>;
19
+
fn into_static(self) -> Self::Output {
20
+
GetBlocks {
21
+
cids: self.cids.into_static(),
22
+
did: self.did.into_static(),
23
+
}
24
+
}
25
+
}
26
+
17
27
#[jacquard_derive::lexicon]
18
28
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
19
29
#[serde(rename_all = "camelCase")]
20
30
pub struct GetBlocksOutput<'a> {}
31
+
impl jacquard_common::IntoStatic for GetBlocksOutput<'_> {
32
+
type Output = GetBlocksOutput<'static>;
33
+
fn into_static(self) -> Self::Output {
34
+
GetBlocksOutput {
35
+
extra_data: self.extra_data.into_static(),
36
+
}
37
+
}
38
+
}
39
+
21
40
#[jacquard_derive::open_union]
22
41
#[derive(
23
42
serde::Serialize,
···
83
102
Ok(())
84
103
}
85
104
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
105
+
}
106
+
}
107
+
}
108
+
109
+
impl jacquard_common::IntoStatic for GetBlocksError<'_> {
110
+
type Output = GetBlocksError<'static>;
111
+
fn into_static(self) -> Self::Output {
112
+
match self {
113
+
GetBlocksError::BlockNotFound(v) => {
114
+
GetBlocksError::BlockNotFound(v.into_static())
115
+
}
116
+
GetBlocksError::RepoNotFound(v) => {
117
+
GetBlocksError::RepoNotFound(v.into_static())
118
+
}
119
+
GetBlocksError::RepoTakendown(v) => {
120
+
GetBlocksError::RepoTakendown(v.into_static())
121
+
}
122
+
GetBlocksError::RepoSuspended(v) => {
123
+
GetBlocksError::RepoSuspended(v.into_static())
124
+
}
125
+
GetBlocksError::RepoDeactivated(v) => {
126
+
GetBlocksError::RepoDeactivated(v.into_static())
127
+
}
128
+
GetBlocksError::Unknown(v) => GetBlocksError::Unknown(v.into_static()),
86
129
}
87
130
}
88
131
}
+19
-1
crates/jacquard-api/src/com_atproto/sync/get_checkout.rs
+19
-1
crates/jacquard-api/src/com_atproto/sync/get_checkout.rs
···
12
12
pub did: jacquard_common::types::string::Did<'a>,
13
13
}
14
14
15
+
impl jacquard_common::IntoStatic for GetCheckout<'_> {
16
+
type Output = GetCheckout<'static>;
17
+
fn into_static(self) -> Self::Output {
18
+
GetCheckout {
19
+
did: self.did.into_static(),
20
+
}
21
+
}
22
+
}
23
+
15
24
#[jacquard_derive::lexicon]
16
25
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
26
#[serde(rename_all = "camelCase")]
18
27
pub struct GetCheckoutOutput<'a> {}
28
+
impl jacquard_common::IntoStatic for GetCheckoutOutput<'_> {
29
+
type Output = GetCheckoutOutput<'static>;
30
+
fn into_static(self) -> Self::Output {
31
+
GetCheckoutOutput {
32
+
extra_data: self.extra_data.into_static(),
33
+
}
34
+
}
35
+
}
36
+
19
37
impl jacquard_common::types::xrpc::XrpcRequest for GetCheckout<'_> {
20
38
const NSID: &'static str = "com.atproto.sync.getCheckout";
21
39
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
22
40
const OUTPUT_ENCODING: &'static str = "application/vnd.ipld.car";
23
41
type Output<'de> = GetCheckoutOutput<'de>;
24
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
42
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
25
43
}
+29
crates/jacquard-api/src/com_atproto/sync/get_head.rs
+29
crates/jacquard-api/src/com_atproto/sync/get_head.rs
···
12
12
pub did: jacquard_common::types::string::Did<'a>,
13
13
}
14
14
15
+
impl jacquard_common::IntoStatic for GetHead<'_> {
16
+
type Output = GetHead<'static>;
17
+
fn into_static(self) -> Self::Output {
18
+
GetHead {
19
+
did: self.did.into_static(),
20
+
}
21
+
}
22
+
}
23
+
15
24
#[jacquard_derive::lexicon]
16
25
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
26
#[serde(rename_all = "camelCase")]
···
20
29
pub root: jacquard_common::types::string::Cid<'a>,
21
30
}
22
31
32
+
impl jacquard_common::IntoStatic for GetHeadOutput<'_> {
33
+
type Output = GetHeadOutput<'static>;
34
+
fn into_static(self) -> Self::Output {
35
+
GetHeadOutput {
36
+
root: self.root.into_static(),
37
+
extra_data: self.extra_data.into_static(),
38
+
}
39
+
}
40
+
}
41
+
23
42
#[jacquard_derive::open_union]
24
43
#[derive(
25
44
serde::Serialize,
···
49
68
Ok(())
50
69
}
51
70
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
71
+
}
72
+
}
73
+
}
74
+
75
+
impl jacquard_common::IntoStatic for GetHeadError<'_> {
76
+
type Output = GetHeadError<'static>;
77
+
fn into_static(self) -> Self::Output {
78
+
match self {
79
+
GetHeadError::HeadNotFound(v) => GetHeadError::HeadNotFound(v.into_static()),
80
+
GetHeadError::Unknown(v) => GetHeadError::Unknown(v.into_static()),
52
81
}
53
82
}
54
83
}
+36
crates/jacquard-api/src/com_atproto/sync/get_host_status.rs
+36
crates/jacquard-api/src/com_atproto/sync/get_host_status.rs
···
12
12
pub hostname: jacquard_common::CowStr<'a>,
13
13
}
14
14
15
+
impl jacquard_common::IntoStatic for GetHostStatus<'_> {
16
+
type Output = GetHostStatus<'static>;
17
+
fn into_static(self) -> Self::Output {
18
+
GetHostStatus {
19
+
hostname: self.hostname.into_static(),
20
+
}
21
+
}
22
+
}
23
+
15
24
#[jacquard_derive::lexicon]
16
25
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
26
#[serde(rename_all = "camelCase")]
···
29
38
pub status: std::option::Option<crate::com_atproto::sync::HostStatus<'a>>,
30
39
}
31
40
41
+
impl jacquard_common::IntoStatic for GetHostStatusOutput<'_> {
42
+
type Output = GetHostStatusOutput<'static>;
43
+
fn into_static(self) -> Self::Output {
44
+
GetHostStatusOutput {
45
+
account_count: self.account_count.into_static(),
46
+
hostname: self.hostname.into_static(),
47
+
seq: self.seq.into_static(),
48
+
status: self.status.into_static(),
49
+
extra_data: self.extra_data.into_static(),
50
+
}
51
+
}
52
+
}
53
+
32
54
#[jacquard_derive::open_union]
33
55
#[derive(
34
56
serde::Serialize,
···
58
80
Ok(())
59
81
}
60
82
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
83
+
}
84
+
}
85
+
}
86
+
87
+
impl jacquard_common::IntoStatic for GetHostStatusError<'_> {
88
+
type Output = GetHostStatusError<'static>;
89
+
fn into_static(self) -> Self::Output {
90
+
match self {
91
+
GetHostStatusError::HostNotFound(v) => {
92
+
GetHostStatusError::HostNotFound(v.into_static())
93
+
}
94
+
GetHostStatusError::Unknown(v) => {
95
+
GetHostStatusError::Unknown(v.into_static())
96
+
}
61
97
}
62
98
}
63
99
}
+43
crates/jacquard-api/src/com_atproto/sync/get_latest_commit.rs
+43
crates/jacquard-api/src/com_atproto/sync/get_latest_commit.rs
···
12
12
pub did: jacquard_common::types::string::Did<'a>,
13
13
}
14
14
15
+
impl jacquard_common::IntoStatic for GetLatestCommit<'_> {
16
+
type Output = GetLatestCommit<'static>;
17
+
fn into_static(self) -> Self::Output {
18
+
GetLatestCommit {
19
+
did: self.did.into_static(),
20
+
}
21
+
}
22
+
}
23
+
15
24
#[jacquard_derive::lexicon]
16
25
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
26
#[serde(rename_all = "camelCase")]
···
19
28
#[serde(borrow)]
20
29
pub cid: jacquard_common::types::string::Cid<'a>,
21
30
pub rev: jacquard_common::types::string::Tid,
31
+
}
32
+
33
+
impl jacquard_common::IntoStatic for GetLatestCommitOutput<'_> {
34
+
type Output = GetLatestCommitOutput<'static>;
35
+
fn into_static(self) -> Self::Output {
36
+
GetLatestCommitOutput {
37
+
cid: self.cid.into_static(),
38
+
rev: self.rev.into_static(),
39
+
extra_data: self.extra_data.into_static(),
40
+
}
41
+
}
22
42
}
23
43
24
44
#[jacquard_derive::open_union]
···
77
97
Ok(())
78
98
}
79
99
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
100
+
}
101
+
}
102
+
}
103
+
104
+
impl jacquard_common::IntoStatic for GetLatestCommitError<'_> {
105
+
type Output = GetLatestCommitError<'static>;
106
+
fn into_static(self) -> Self::Output {
107
+
match self {
108
+
GetLatestCommitError::RepoNotFound(v) => {
109
+
GetLatestCommitError::RepoNotFound(v.into_static())
110
+
}
111
+
GetLatestCommitError::RepoTakendown(v) => {
112
+
GetLatestCommitError::RepoTakendown(v.into_static())
113
+
}
114
+
GetLatestCommitError::RepoSuspended(v) => {
115
+
GetLatestCommitError::RepoSuspended(v.into_static())
116
+
}
117
+
GetLatestCommitError::RepoDeactivated(v) => {
118
+
GetLatestCommitError::RepoDeactivated(v.into_static())
119
+
}
120
+
GetLatestCommitError::Unknown(v) => {
121
+
GetLatestCommitError::Unknown(v.into_static())
122
+
}
80
123
}
81
124
}
82
125
}
+44
crates/jacquard-api/src/com_atproto/sync/get_record.rs
+44
crates/jacquard-api/src/com_atproto/sync/get_record.rs
···
18
18
>,
19
19
}
20
20
21
+
impl jacquard_common::IntoStatic for GetRecord<'_> {
22
+
type Output = GetRecord<'static>;
23
+
fn into_static(self) -> Self::Output {
24
+
GetRecord {
25
+
collection: self.collection.into_static(),
26
+
did: self.did.into_static(),
27
+
rkey: self.rkey.into_static(),
28
+
}
29
+
}
30
+
}
31
+
21
32
#[jacquard_derive::lexicon]
22
33
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
23
34
#[serde(rename_all = "camelCase")]
24
35
pub struct GetRecordOutput<'a> {}
36
+
impl jacquard_common::IntoStatic for GetRecordOutput<'_> {
37
+
type Output = GetRecordOutput<'static>;
38
+
fn into_static(self) -> Self::Output {
39
+
GetRecordOutput {
40
+
extra_data: self.extra_data.into_static(),
41
+
}
42
+
}
43
+
}
44
+
25
45
#[jacquard_derive::open_union]
26
46
#[derive(
27
47
serde::Serialize,
···
87
107
Ok(())
88
108
}
89
109
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
110
+
}
111
+
}
112
+
}
113
+
114
+
impl jacquard_common::IntoStatic for GetRecordError<'_> {
115
+
type Output = GetRecordError<'static>;
116
+
fn into_static(self) -> Self::Output {
117
+
match self {
118
+
GetRecordError::RecordNotFound(v) => {
119
+
GetRecordError::RecordNotFound(v.into_static())
120
+
}
121
+
GetRecordError::RepoNotFound(v) => {
122
+
GetRecordError::RepoNotFound(v.into_static())
123
+
}
124
+
GetRecordError::RepoTakendown(v) => {
125
+
GetRecordError::RepoTakendown(v.into_static())
126
+
}
127
+
GetRecordError::RepoSuspended(v) => {
128
+
GetRecordError::RepoSuspended(v.into_static())
129
+
}
130
+
GetRecordError::RepoDeactivated(v) => {
131
+
GetRecordError::RepoDeactivated(v.into_static())
132
+
}
133
+
GetRecordError::Unknown(v) => GetRecordError::Unknown(v.into_static()),
90
134
}
91
135
}
92
136
}
+38
crates/jacquard-api/src/com_atproto/sync/get_repo.rs
+38
crates/jacquard-api/src/com_atproto/sync/get_repo.rs
···
14
14
pub since: std::option::Option<jacquard_common::types::string::Tid>,
15
15
}
16
16
17
+
impl jacquard_common::IntoStatic for GetRepo<'_> {
18
+
type Output = GetRepo<'static>;
19
+
fn into_static(self) -> Self::Output {
20
+
GetRepo {
21
+
did: self.did.into_static(),
22
+
since: self.since.into_static(),
23
+
}
24
+
}
25
+
}
26
+
17
27
#[jacquard_derive::lexicon]
18
28
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
19
29
#[serde(rename_all = "camelCase")]
20
30
pub struct GetRepoOutput<'a> {}
31
+
impl jacquard_common::IntoStatic for GetRepoOutput<'_> {
32
+
type Output = GetRepoOutput<'static>;
33
+
fn into_static(self) -> Self::Output {
34
+
GetRepoOutput {
35
+
extra_data: self.extra_data.into_static(),
36
+
}
37
+
}
38
+
}
39
+
21
40
#[jacquard_derive::open_union]
22
41
#[derive(
23
42
serde::Serialize,
···
74
93
Ok(())
75
94
}
76
95
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
96
+
}
97
+
}
98
+
}
99
+
100
+
impl jacquard_common::IntoStatic for GetRepoError<'_> {
101
+
type Output = GetRepoError<'static>;
102
+
fn into_static(self) -> Self::Output {
103
+
match self {
104
+
GetRepoError::RepoNotFound(v) => GetRepoError::RepoNotFound(v.into_static()),
105
+
GetRepoError::RepoTakendown(v) => {
106
+
GetRepoError::RepoTakendown(v.into_static())
107
+
}
108
+
GetRepoError::RepoSuspended(v) => {
109
+
GetRepoError::RepoSuspended(v.into_static())
110
+
}
111
+
GetRepoError::RepoDeactivated(v) => {
112
+
GetRepoError::RepoDeactivated(v.into_static())
113
+
}
114
+
GetRepoError::Unknown(v) => GetRepoError::Unknown(v.into_static()),
77
115
}
78
116
}
79
117
}
+36
crates/jacquard-api/src/com_atproto/sync/get_repo_status.rs
+36
crates/jacquard-api/src/com_atproto/sync/get_repo_status.rs
···
12
12
pub did: jacquard_common::types::string::Did<'a>,
13
13
}
14
14
15
+
impl jacquard_common::IntoStatic for GetRepoStatus<'_> {
16
+
type Output = GetRepoStatus<'static>;
17
+
fn into_static(self) -> Self::Output {
18
+
GetRepoStatus {
19
+
did: self.did.into_static(),
20
+
}
21
+
}
22
+
}
23
+
15
24
#[jacquard_derive::lexicon]
16
25
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
26
#[serde(rename_all = "camelCase")]
···
28
37
pub status: std::option::Option<jacquard_common::CowStr<'a>>,
29
38
}
30
39
40
+
impl jacquard_common::IntoStatic for GetRepoStatusOutput<'_> {
41
+
type Output = GetRepoStatusOutput<'static>;
42
+
fn into_static(self) -> Self::Output {
43
+
GetRepoStatusOutput {
44
+
active: self.active.into_static(),
45
+
did: self.did.into_static(),
46
+
rev: self.rev.into_static(),
47
+
status: self.status.into_static(),
48
+
extra_data: self.extra_data.into_static(),
49
+
}
50
+
}
51
+
}
52
+
31
53
#[jacquard_derive::open_union]
32
54
#[derive(
33
55
serde::Serialize,
···
57
79
Ok(())
58
80
}
59
81
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
82
+
}
83
+
}
84
+
}
85
+
86
+
impl jacquard_common::IntoStatic for GetRepoStatusError<'_> {
87
+
type Output = GetRepoStatusError<'static>;
88
+
fn into_static(self) -> Self::Output {
89
+
match self {
90
+
GetRepoStatusError::RepoNotFound(v) => {
91
+
GetRepoStatusError::RepoNotFound(v.into_static())
92
+
}
93
+
GetRepoStatusError::Unknown(v) => {
94
+
GetRepoStatusError::Unknown(v.into_static())
95
+
}
60
96
}
61
97
}
62
98
}
+42
-8
crates/jacquard-api/src/com_atproto/sync/list_blobs.rs
+42
-8
crates/jacquard-api/src/com_atproto/sync/list_blobs.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct ListBlobs<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
13
13
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
14
14
#[serde(borrow)]
15
15
pub did: jacquard_common::types::string::Did<'a>,
16
+
///(default: 500, min: 1, max: 1000)
16
17
#[serde(skip_serializing_if = "std::option::Option::is_none")]
17
18
pub limit: std::option::Option<i64>,
18
19
#[serde(skip_serializing_if = "std::option::Option::is_none")]
19
20
pub since: std::option::Option<jacquard_common::types::string::Tid>,
20
21
}
21
22
22
-
impl Default for ListBlobs<'_> {
23
-
fn default() -> Self {
24
-
Self {
25
-
cursor: Default::default(),
26
-
did: Default::default(),
27
-
limit: Some(500i64),
28
-
since: Default::default(),
23
+
impl jacquard_common::IntoStatic for ListBlobs<'_> {
24
+
type Output = ListBlobs<'static>;
25
+
fn into_static(self) -> Self::Output {
26
+
ListBlobs {
27
+
cursor: self.cursor.into_static(),
28
+
did: self.did.into_static(),
29
+
limit: self.limit.into_static(),
30
+
since: self.since.into_static(),
29
31
}
30
32
}
31
33
}
···
41
43
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
42
44
}
43
45
46
+
impl jacquard_common::IntoStatic for ListBlobsOutput<'_> {
47
+
type Output = ListBlobsOutput<'static>;
48
+
fn into_static(self) -> Self::Output {
49
+
ListBlobsOutput {
50
+
cids: self.cids.into_static(),
51
+
cursor: self.cursor.into_static(),
52
+
extra_data: self.extra_data.into_static(),
53
+
}
54
+
}
55
+
}
56
+
44
57
#[jacquard_derive::open_union]
45
58
#[derive(
46
59
serde::Serialize,
···
97
110
Ok(())
98
111
}
99
112
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
113
+
}
114
+
}
115
+
}
116
+
117
+
impl jacquard_common::IntoStatic for ListBlobsError<'_> {
118
+
type Output = ListBlobsError<'static>;
119
+
fn into_static(self) -> Self::Output {
120
+
match self {
121
+
ListBlobsError::RepoNotFound(v) => {
122
+
ListBlobsError::RepoNotFound(v.into_static())
123
+
}
124
+
ListBlobsError::RepoTakendown(v) => {
125
+
ListBlobsError::RepoTakendown(v.into_static())
126
+
}
127
+
ListBlobsError::RepoSuspended(v) => {
128
+
ListBlobsError::RepoSuspended(v.into_static())
129
+
}
130
+
ListBlobsError::RepoDeactivated(v) => {
131
+
ListBlobsError::RepoDeactivated(v.into_static())
132
+
}
133
+
ListBlobsError::Unknown(v) => ListBlobsError::Unknown(v.into_static()),
100
134
}
101
135
}
102
136
}
+33
-7
crates/jacquard-api/src/com_atproto/sync/list_hosts.rs
+33
-7
crates/jacquard-api/src/com_atproto/sync/list_hosts.rs
···
22
22
pub status: std::option::Option<crate::com_atproto::sync::HostStatus<'a>>,
23
23
}
24
24
25
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
25
+
impl jacquard_common::IntoStatic for Host<'_> {
26
+
type Output = Host<'static>;
27
+
fn into_static(self) -> Self::Output {
28
+
Host {
29
+
account_count: self.account_count.into_static(),
30
+
hostname: self.hostname.into_static(),
31
+
seq: self.seq.into_static(),
32
+
status: self.status.into_static(),
33
+
extra_data: self.extra_data.into_static(),
34
+
}
35
+
}
36
+
}
37
+
38
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
26
39
#[serde(rename_all = "camelCase")]
27
40
pub struct ListHosts<'a> {
28
41
#[serde(skip_serializing_if = "std::option::Option::is_none")]
29
42
#[serde(borrow)]
30
43
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
44
+
///(default: 200, min: 1, max: 1000)
31
45
#[serde(skip_serializing_if = "std::option::Option::is_none")]
32
46
pub limit: std::option::Option<i64>,
33
47
}
34
48
35
-
impl Default for ListHosts<'_> {
36
-
fn default() -> Self {
37
-
Self {
38
-
cursor: Default::default(),
39
-
limit: Some(200i64),
49
+
impl jacquard_common::IntoStatic for ListHosts<'_> {
50
+
type Output = ListHosts<'static>;
51
+
fn into_static(self) -> Self::Output {
52
+
ListHosts {
53
+
cursor: self.cursor.into_static(),
54
+
limit: self.limit.into_static(),
40
55
}
41
56
}
42
57
}
···
53
68
pub hosts: Vec<jacquard_common::types::value::Data<'a>>,
54
69
}
55
70
71
+
impl jacquard_common::IntoStatic for ListHostsOutput<'_> {
72
+
type Output = ListHostsOutput<'static>;
73
+
fn into_static(self) -> Self::Output {
74
+
ListHostsOutput {
75
+
cursor: self.cursor.into_static(),
76
+
hosts: self.hosts.into_static(),
77
+
extra_data: self.extra_data.into_static(),
78
+
}
79
+
}
80
+
}
81
+
56
82
impl jacquard_common::types::xrpc::XrpcRequest for ListHosts<'_> {
57
83
const NSID: &'static str = "com.atproto.sync.listHosts";
58
84
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
59
85
const OUTPUT_ENCODING: &'static str = "application/json";
60
86
type Output<'de> = ListHostsOutput<'de>;
61
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
87
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
62
88
}
+34
-7
crates/jacquard-api/src/com_atproto/sync/list_repos.rs
+34
-7
crates/jacquard-api/src/com_atproto/sync/list_repos.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct ListRepos<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
12
#[serde(borrow)]
13
13
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
14
+
///(default: 500, min: 1, max: 1000)
14
15
#[serde(skip_serializing_if = "std::option::Option::is_none")]
15
16
pub limit: std::option::Option<i64>,
16
17
}
17
18
18
-
impl Default for ListRepos<'_> {
19
-
fn default() -> Self {
20
-
Self {
21
-
cursor: Default::default(),
22
-
limit: Some(500i64),
19
+
impl jacquard_common::IntoStatic for ListRepos<'_> {
20
+
type Output = ListRepos<'static>;
21
+
fn into_static(self) -> Self::Output {
22
+
ListRepos {
23
+
cursor: self.cursor.into_static(),
24
+
limit: self.limit.into_static(),
23
25
}
24
26
}
25
27
}
···
35
37
pub repos: Vec<jacquard_common::types::value::Data<'a>>,
36
38
}
37
39
40
+
impl jacquard_common::IntoStatic for ListReposOutput<'_> {
41
+
type Output = ListReposOutput<'static>;
42
+
fn into_static(self) -> Self::Output {
43
+
ListReposOutput {
44
+
cursor: self.cursor.into_static(),
45
+
repos: self.repos.into_static(),
46
+
extra_data: self.extra_data.into_static(),
47
+
}
48
+
}
49
+
}
50
+
38
51
impl jacquard_common::types::xrpc::XrpcRequest for ListRepos<'_> {
39
52
const NSID: &'static str = "com.atproto.sync.listRepos";
40
53
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
41
54
const OUTPUT_ENCODING: &'static str = "application/json";
42
55
type Output<'de> = ListReposOutput<'de>;
43
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
56
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
44
57
}
45
58
46
59
#[jacquard_derive::lexicon]
···
59
72
#[serde(skip_serializing_if = "std::option::Option::is_none")]
60
73
#[serde(borrow)]
61
74
pub status: std::option::Option<jacquard_common::CowStr<'a>>,
75
+
}
76
+
77
+
impl jacquard_common::IntoStatic for Repo<'_> {
78
+
type Output = Repo<'static>;
79
+
fn into_static(self) -> Self::Output {
80
+
Repo {
81
+
active: self.active.into_static(),
82
+
did: self.did.into_static(),
83
+
head: self.head.into_static(),
84
+
rev: self.rev.into_static(),
85
+
status: self.status.into_static(),
86
+
extra_data: self.extra_data.into_static(),
87
+
}
88
+
}
62
89
}
+31
-8
crates/jacquard-api/src/com_atproto/sync/list_repos_by_collection.rs
+31
-8
crates/jacquard-api/src/com_atproto/sync/list_repos_by_collection.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct ListReposByCollection<'a> {
11
11
#[serde(borrow)]
···
13
13
#[serde(skip_serializing_if = "std::option::Option::is_none")]
14
14
#[serde(borrow)]
15
15
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
16
+
///(default: 500, min: 1, max: 2000)
16
17
#[serde(skip_serializing_if = "std::option::Option::is_none")]
17
18
pub limit: std::option::Option<i64>,
18
19
}
19
20
20
-
impl Default for ListReposByCollection<'_> {
21
-
fn default() -> Self {
22
-
Self {
23
-
collection: Default::default(),
24
-
cursor: Default::default(),
25
-
limit: Some(500i64),
21
+
impl jacquard_common::IntoStatic for ListReposByCollection<'_> {
22
+
type Output = ListReposByCollection<'static>;
23
+
fn into_static(self) -> Self::Output {
24
+
ListReposByCollection {
25
+
collection: self.collection.into_static(),
26
+
cursor: self.cursor.into_static(),
27
+
limit: self.limit.into_static(),
26
28
}
27
29
}
28
30
}
···
38
40
pub repos: Vec<jacquard_common::types::value::Data<'a>>,
39
41
}
40
42
43
+
impl jacquard_common::IntoStatic for ListReposByCollectionOutput<'_> {
44
+
type Output = ListReposByCollectionOutput<'static>;
45
+
fn into_static(self) -> Self::Output {
46
+
ListReposByCollectionOutput {
47
+
cursor: self.cursor.into_static(),
48
+
repos: self.repos.into_static(),
49
+
extra_data: self.extra_data.into_static(),
50
+
}
51
+
}
52
+
}
53
+
41
54
impl jacquard_common::types::xrpc::XrpcRequest for ListReposByCollection<'_> {
42
55
const NSID: &'static str = "com.atproto.sync.listReposByCollection";
43
56
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
44
57
const OUTPUT_ENCODING: &'static str = "application/json";
45
58
type Output<'de> = ListReposByCollectionOutput<'de>;
46
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
59
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
47
60
}
48
61
49
62
#[jacquard_derive::lexicon]
···
52
65
pub struct Repo<'a> {
53
66
#[serde(borrow)]
54
67
pub did: jacquard_common::types::string::Did<'a>,
68
+
}
69
+
70
+
impl jacquard_common::IntoStatic for Repo<'_> {
71
+
type Output = Repo<'static>;
72
+
fn into_static(self) -> Self::Output {
73
+
Repo {
74
+
did: self.did.into_static(),
75
+
extra_data: self.extra_data.into_static(),
76
+
}
77
+
}
55
78
}
+11
-1
crates/jacquard-api/src/com_atproto/sync/notify_of_update.rs
+11
-1
crates/jacquard-api/src/com_atproto/sync/notify_of_update.rs
···
14
14
pub hostname: jacquard_common::CowStr<'a>,
15
15
}
16
16
17
+
impl jacquard_common::IntoStatic for NotifyOfUpdate<'_> {
18
+
type Output = NotifyOfUpdate<'static>;
19
+
fn into_static(self) -> Self::Output {
20
+
NotifyOfUpdate {
21
+
hostname: self.hostname.into_static(),
22
+
extra_data: self.extra_data.into_static(),
23
+
}
24
+
}
25
+
}
26
+
17
27
impl jacquard_common::types::xrpc::XrpcRequest for NotifyOfUpdate<'_> {
18
28
const NSID: &'static str = "com.atproto.sync.notifyOfUpdate";
19
29
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
21
31
);
22
32
const OUTPUT_ENCODING: &'static str = "application/json";
23
33
type Output<'de> = ();
24
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
34
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
25
35
}
+22
crates/jacquard-api/src/com_atproto/sync/request_crawl.rs
+22
crates/jacquard-api/src/com_atproto/sync/request_crawl.rs
···
14
14
pub hostname: jacquard_common::CowStr<'a>,
15
15
}
16
16
17
+
impl jacquard_common::IntoStatic for RequestCrawl<'_> {
18
+
type Output = RequestCrawl<'static>;
19
+
fn into_static(self) -> Self::Output {
20
+
RequestCrawl {
21
+
hostname: self.hostname.into_static(),
22
+
extra_data: self.extra_data.into_static(),
23
+
}
24
+
}
25
+
}
26
+
17
27
#[jacquard_derive::open_union]
18
28
#[derive(
19
29
serde::Serialize,
···
43
53
Ok(())
44
54
}
45
55
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
56
+
}
57
+
}
58
+
}
59
+
60
+
impl jacquard_common::IntoStatic for RequestCrawlError<'_> {
61
+
type Output = RequestCrawlError<'static>;
62
+
fn into_static(self) -> Self::Output {
63
+
match self {
64
+
RequestCrawlError::HostBanned(v) => {
65
+
RequestCrawlError::HostBanned(v.into_static())
66
+
}
67
+
RequestCrawlError::Unknown(v) => RequestCrawlError::Unknown(v.into_static()),
46
68
}
47
69
}
48
70
}
+136
crates/jacquard-api/src/com_atproto/sync/subscribe_repos.rs
+136
crates/jacquard-api/src/com_atproto/sync/subscribe_repos.rs
···
22
22
pub time: jacquard_common::types::string::Datetime,
23
23
}
24
24
25
+
impl jacquard_common::IntoStatic for Account<'_> {
26
+
type Output = Account<'static>;
27
+
fn into_static(self) -> Self::Output {
28
+
Account {
29
+
active: self.active.into_static(),
30
+
did: self.did.into_static(),
31
+
seq: self.seq.into_static(),
32
+
status: self.status.into_static(),
33
+
time: self.time.into_static(),
34
+
extra_data: self.extra_data.into_static(),
35
+
}
36
+
}
37
+
}
38
+
25
39
///Represents an update of repository state. Note that empty commits are allowed, which include no repo data changes, but an update to rev and signature.
26
40
#[jacquard_derive::lexicon]
27
41
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
57
71
pub too_big: bool,
58
72
}
59
73
74
+
impl jacquard_common::IntoStatic for Commit<'_> {
75
+
type Output = Commit<'static>;
76
+
fn into_static(self) -> Self::Output {
77
+
Commit {
78
+
blobs: self.blobs.into_static(),
79
+
blocks: self.blocks.into_static(),
80
+
commit: self.commit.into_static(),
81
+
ops: self.ops.into_static(),
82
+
prev_data: self.prev_data.into_static(),
83
+
rebase: self.rebase.into_static(),
84
+
repo: self.repo.into_static(),
85
+
rev: self.rev.into_static(),
86
+
seq: self.seq.into_static(),
87
+
since: self.since.into_static(),
88
+
time: self.time.into_static(),
89
+
too_big: self.too_big.into_static(),
90
+
extra_data: self.extra_data.into_static(),
91
+
}
92
+
}
93
+
}
94
+
60
95
///Represents a change to an account's identity. Could be an updated handle, signing key, or pds hosting endpoint. Serves as a prod to all downstream services to refresh their identity cache.
61
96
#[jacquard_derive::lexicon]
62
97
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
72
107
pub time: jacquard_common::types::string::Datetime,
73
108
}
74
109
110
+
impl jacquard_common::IntoStatic for Identity<'_> {
111
+
type Output = Identity<'static>;
112
+
fn into_static(self) -> Self::Output {
113
+
Identity {
114
+
did: self.did.into_static(),
115
+
handle: self.handle.into_static(),
116
+
seq: self.seq.into_static(),
117
+
time: self.time.into_static(),
118
+
extra_data: self.extra_data.into_static(),
119
+
}
120
+
}
121
+
}
122
+
75
123
#[jacquard_derive::lexicon]
76
124
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
77
125
#[serde(rename_all = "camelCase")]
···
83
131
pub name: jacquard_common::CowStr<'a>,
84
132
}
85
133
134
+
impl jacquard_common::IntoStatic for Info<'_> {
135
+
type Output = Info<'static>;
136
+
fn into_static(self) -> Self::Output {
137
+
Info {
138
+
message: self.message.into_static(),
139
+
name: self.name.into_static(),
140
+
extra_data: self.extra_data.into_static(),
141
+
}
142
+
}
143
+
}
144
+
86
145
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
87
146
#[serde(rename_all = "camelCase")]
88
147
pub struct SubscribeRepos {
···
90
149
pub cursor: std::option::Option<i64>,
91
150
}
92
151
152
+
impl jacquard_common::IntoStatic for SubscribeRepos {
153
+
type Output = SubscribeRepos;
154
+
fn into_static(self) -> Self::Output {
155
+
self
156
+
}
157
+
}
158
+
93
159
#[jacquard_derive::open_union]
94
160
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
95
161
#[serde(tag = "$type")]
···
107
173
Info(Box<jacquard_common::types::value::Data<'a>>),
108
174
}
109
175
176
+
impl jacquard_common::IntoStatic for SubscribeReposMessage<'_> {
177
+
type Output = SubscribeReposMessage<'static>;
178
+
fn into_static(self) -> Self::Output {
179
+
match self {
180
+
SubscribeReposMessage::Commit(v) => {
181
+
SubscribeReposMessage::Commit(v.into_static())
182
+
}
183
+
SubscribeReposMessage::Sync(v) => {
184
+
SubscribeReposMessage::Sync(v.into_static())
185
+
}
186
+
SubscribeReposMessage::Identity(v) => {
187
+
SubscribeReposMessage::Identity(v.into_static())
188
+
}
189
+
SubscribeReposMessage::Account(v) => {
190
+
SubscribeReposMessage::Account(v.into_static())
191
+
}
192
+
SubscribeReposMessage::Info(v) => {
193
+
SubscribeReposMessage::Info(v.into_static())
194
+
}
195
+
SubscribeReposMessage::Unknown(v) => {
196
+
SubscribeReposMessage::Unknown(v.into_static())
197
+
}
198
+
}
199
+
}
200
+
}
201
+
110
202
#[jacquard_derive::open_union]
111
203
#[derive(
112
204
serde::Serialize,
···
150
242
}
151
243
}
152
244
245
+
impl jacquard_common::IntoStatic for SubscribeReposError<'_> {
246
+
type Output = SubscribeReposError<'static>;
247
+
fn into_static(self) -> Self::Output {
248
+
match self {
249
+
SubscribeReposError::FutureCursor(v) => {
250
+
SubscribeReposError::FutureCursor(v.into_static())
251
+
}
252
+
SubscribeReposError::ConsumerTooSlow(v) => {
253
+
SubscribeReposError::ConsumerTooSlow(v.into_static())
254
+
}
255
+
SubscribeReposError::Unknown(v) => {
256
+
SubscribeReposError::Unknown(v.into_static())
257
+
}
258
+
}
259
+
}
260
+
}
261
+
153
262
///A repo operation, ie a mutation of a single record.
154
263
#[jacquard_derive::lexicon]
155
264
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
168
277
pub prev: std::option::Option<jacquard_common::types::cid::CidLink<'a>>,
169
278
}
170
279
280
+
impl jacquard_common::IntoStatic for RepoOp<'_> {
281
+
type Output = RepoOp<'static>;
282
+
fn into_static(self) -> Self::Output {
283
+
RepoOp {
284
+
action: self.action.into_static(),
285
+
cid: self.cid.into_static(),
286
+
path: self.path.into_static(),
287
+
prev: self.prev.into_static(),
288
+
extra_data: self.extra_data.into_static(),
289
+
}
290
+
}
291
+
}
292
+
171
293
///Updates the repo to a new state, without necessarily including that state on the firehose. Used to recover from broken commit streams, data loss incidents, or in situations where upstream host does not know recent state of the repository.
172
294
#[jacquard_derive::lexicon]
173
295
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
185
307
pub seq: i64,
186
308
///Timestamp of when this message was originally broadcast.
187
309
pub time: jacquard_common::types::string::Datetime,
310
+
}
311
+
312
+
impl jacquard_common::IntoStatic for Sync<'_> {
313
+
type Output = Sync<'static>;
314
+
fn into_static(self) -> Self::Output {
315
+
Sync {
316
+
blocks: self.blocks.into_static(),
317
+
did: self.did.into_static(),
318
+
rev: self.rev.into_static(),
319
+
seq: self.seq.into_static(),
320
+
time: self.time.into_static(),
321
+
extra_data: self.extra_data.into_static(),
322
+
}
323
+
}
188
324
}
+20
-1
crates/jacquard-api/src/com_atproto/temp/add_reserved_handle.rs
+20
-1
crates/jacquard-api/src/com_atproto/temp/add_reserved_handle.rs
···
13
13
pub handle: jacquard_common::CowStr<'a>,
14
14
}
15
15
16
+
impl jacquard_common::IntoStatic for AddReservedHandle<'_> {
17
+
type Output = AddReservedHandle<'static>;
18
+
fn into_static(self) -> Self::Output {
19
+
AddReservedHandle {
20
+
handle: self.handle.into_static(),
21
+
extra_data: self.extra_data.into_static(),
22
+
}
23
+
}
24
+
}
25
+
16
26
#[jacquard_derive::lexicon]
17
27
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
18
28
#[serde(rename_all = "camelCase")]
19
29
pub struct AddReservedHandleOutput<'a> {}
30
+
impl jacquard_common::IntoStatic for AddReservedHandleOutput<'_> {
31
+
type Output = AddReservedHandleOutput<'static>;
32
+
fn into_static(self) -> Self::Output {
33
+
AddReservedHandleOutput {
34
+
extra_data: self.extra_data.into_static(),
35
+
}
36
+
}
37
+
}
38
+
20
39
impl jacquard_common::types::xrpc::XrpcRequest for AddReservedHandle<'_> {
21
40
const NSID: &'static str = "com.atproto.temp.addReservedHandle";
22
41
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
24
43
);
25
44
const OUTPUT_ENCODING: &'static str = "application/json";
26
45
type Output<'de> = AddReservedHandleOutput<'de>;
27
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
46
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
28
47
}
+77
crates/jacquard-api/src/com_atproto/temp/check_handle_availability.rs
+77
crates/jacquard-api/src/com_atproto/temp/check_handle_availability.rs
···
17
17
pub handle: jacquard_common::types::string::Handle<'a>,
18
18
}
19
19
20
+
impl jacquard_common::IntoStatic for CheckHandleAvailability<'_> {
21
+
type Output = CheckHandleAvailability<'static>;
22
+
fn into_static(self) -> Self::Output {
23
+
CheckHandleAvailability {
24
+
birth_date: self.birth_date.into_static(),
25
+
email: self.email.into_static(),
26
+
handle: self.handle.into_static(),
27
+
}
28
+
}
29
+
}
30
+
20
31
#[jacquard_derive::lexicon]
21
32
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
22
33
#[serde(rename_all = "camelCase")]
···
33
44
#[serde(tag = "$type")]
34
45
#[serde(bound(deserialize = "'de: 'a"))]
35
46
pub enum CheckHandleAvailabilityOutputRecordResult<'a> {}
47
+
impl jacquard_common::IntoStatic for CheckHandleAvailabilityOutputRecordResult<'_> {
48
+
type Output = CheckHandleAvailabilityOutputRecordResult<'static>;
49
+
fn into_static(self) -> Self::Output {
50
+
match self {
51
+
CheckHandleAvailabilityOutputRecordResult::Unknown(v) => {
52
+
CheckHandleAvailabilityOutputRecordResult::Unknown(v.into_static())
53
+
}
54
+
}
55
+
}
56
+
}
57
+
58
+
impl jacquard_common::IntoStatic for CheckHandleAvailabilityOutput<'_> {
59
+
type Output = CheckHandleAvailabilityOutput<'static>;
60
+
fn into_static(self) -> Self::Output {
61
+
CheckHandleAvailabilityOutput {
62
+
handle: self.handle.into_static(),
63
+
result: self.result.into_static(),
64
+
extra_data: self.extra_data.into_static(),
65
+
}
66
+
}
67
+
}
68
+
36
69
#[jacquard_derive::open_union]
37
70
#[derive(
38
71
serde::Serialize,
···
67
100
}
68
101
}
69
102
103
+
impl jacquard_common::IntoStatic for CheckHandleAvailabilityError<'_> {
104
+
type Output = CheckHandleAvailabilityError<'static>;
105
+
fn into_static(self) -> Self::Output {
106
+
match self {
107
+
CheckHandleAvailabilityError::InvalidEmail(v) => {
108
+
CheckHandleAvailabilityError::InvalidEmail(v.into_static())
109
+
}
110
+
CheckHandleAvailabilityError::Unknown(v) => {
111
+
CheckHandleAvailabilityError::Unknown(v.into_static())
112
+
}
113
+
}
114
+
}
115
+
}
116
+
70
117
impl jacquard_common::types::xrpc::XrpcRequest for CheckHandleAvailability<'_> {
71
118
const NSID: &'static str = "com.atproto.temp.checkHandleAvailability";
72
119
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
···
80
127
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
81
128
#[serde(rename_all = "camelCase")]
82
129
pub struct ResultAvailable<'a> {}
130
+
impl jacquard_common::IntoStatic for ResultAvailable<'_> {
131
+
type Output = ResultAvailable<'static>;
132
+
fn into_static(self) -> Self::Output {
133
+
ResultAvailable {
134
+
extra_data: self.extra_data.into_static(),
135
+
}
136
+
}
137
+
}
138
+
83
139
///Indicates the provided handle is unavailable and gives suggestions of available handles.
84
140
#[jacquard_derive::lexicon]
85
141
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
92
148
>,
93
149
}
94
150
151
+
impl jacquard_common::IntoStatic for ResultUnavailable<'_> {
152
+
type Output = ResultUnavailable<'static>;
153
+
fn into_static(self) -> Self::Output {
154
+
ResultUnavailable {
155
+
suggestions: self.suggestions.into_static(),
156
+
extra_data: self.extra_data.into_static(),
157
+
}
158
+
}
159
+
}
160
+
95
161
#[jacquard_derive::lexicon]
96
162
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
97
163
#[serde(rename_all = "camelCase")]
···
101
167
///Method used to build this suggestion. Should be considered opaque to clients. Can be used for metrics.
102
168
#[serde(borrow)]
103
169
pub method: jacquard_common::CowStr<'a>,
170
+
}
171
+
172
+
impl jacquard_common::IntoStatic for Suggestion<'_> {
173
+
type Output = Suggestion<'static>;
174
+
fn into_static(self) -> Self::Output {
175
+
Suggestion {
176
+
handle: self.handle.into_static(),
177
+
method: self.method.into_static(),
178
+
extra_data: self.extra_data.into_static(),
179
+
}
180
+
}
104
181
}
+13
-1
crates/jacquard-api/src/com_atproto/temp/check_signup_queue.rs
+13
-1
crates/jacquard-api/src/com_atproto/temp/check_signup_queue.rs
···
16
16
pub place_in_queue: std::option::Option<i64>,
17
17
}
18
18
19
+
impl jacquard_common::IntoStatic for CheckSignupQueueOutput<'_> {
20
+
type Output = CheckSignupQueueOutput<'static>;
21
+
fn into_static(self) -> Self::Output {
22
+
CheckSignupQueueOutput {
23
+
activated: self.activated.into_static(),
24
+
estimated_time_ms: self.estimated_time_ms.into_static(),
25
+
place_in_queue: self.place_in_queue.into_static(),
26
+
extra_data: self.extra_data.into_static(),
27
+
}
28
+
}
29
+
}
30
+
19
31
/// XRPC request marker type
20
32
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]
21
33
pub struct CheckSignupQueue;
···
24
36
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
25
37
const OUTPUT_ENCODING: &'static str = "application/json";
26
38
type Output<'de> = CheckSignupQueueOutput<'de>;
27
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
39
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
28
40
}
+33
crates/jacquard-api/src/com_atproto/temp/dereference_scope.rs
+33
crates/jacquard-api/src/com_atproto/temp/dereference_scope.rs
···
12
12
pub scope: jacquard_common::CowStr<'a>,
13
13
}
14
14
15
+
impl jacquard_common::IntoStatic for DereferenceScope<'_> {
16
+
type Output = DereferenceScope<'static>;
17
+
fn into_static(self) -> Self::Output {
18
+
DereferenceScope {
19
+
scope: self.scope.into_static(),
20
+
}
21
+
}
22
+
}
23
+
15
24
#[jacquard_derive::lexicon]
16
25
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
26
#[serde(rename_all = "camelCase")]
···
21
30
pub scope: jacquard_common::CowStr<'a>,
22
31
}
23
32
33
+
impl jacquard_common::IntoStatic for DereferenceScopeOutput<'_> {
34
+
type Output = DereferenceScopeOutput<'static>;
35
+
fn into_static(self) -> Self::Output {
36
+
DereferenceScopeOutput {
37
+
scope: self.scope.into_static(),
38
+
extra_data: self.extra_data.into_static(),
39
+
}
40
+
}
41
+
}
42
+
24
43
#[jacquard_derive::open_union]
25
44
#[derive(
26
45
serde::Serialize,
···
51
70
Ok(())
52
71
}
53
72
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
73
+
}
74
+
}
75
+
}
76
+
77
+
impl jacquard_common::IntoStatic for DereferenceScopeError<'_> {
78
+
type Output = DereferenceScopeError<'static>;
79
+
fn into_static(self) -> Self::Output {
80
+
match self {
81
+
DereferenceScopeError::InvalidScopeReference(v) => {
82
+
DereferenceScopeError::InvalidScopeReference(v.into_static())
83
+
}
84
+
DereferenceScopeError::Unknown(v) => {
85
+
DereferenceScopeError::Unknown(v.into_static())
86
+
}
54
87
}
55
88
}
56
89
}
+20
-2
crates/jacquard-api/src/com_atproto/temp/fetch_labels.rs
+20
-2
crates/jacquard-api/src/com_atproto/temp/fetch_labels.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct FetchLabels {
11
+
///(default: 50, min: 1, max: 250)
11
12
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
13
pub limit: std::option::Option<i64>,
13
14
#[serde(skip_serializing_if = "std::option::Option::is_none")]
14
15
pub since: std::option::Option<i64>,
15
16
}
16
17
18
+
impl jacquard_common::IntoStatic for FetchLabels {
19
+
type Output = FetchLabels;
20
+
fn into_static(self) -> Self::Output {
21
+
self
22
+
}
23
+
}
24
+
17
25
#[jacquard_derive::lexicon]
18
26
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
19
27
#[serde(rename_all = "camelCase")]
···
22
30
pub labels: Vec<crate::com_atproto::label::Label<'a>>,
23
31
}
24
32
33
+
impl jacquard_common::IntoStatic for FetchLabelsOutput<'_> {
34
+
type Output = FetchLabelsOutput<'static>;
35
+
fn into_static(self) -> Self::Output {
36
+
FetchLabelsOutput {
37
+
labels: self.labels.into_static(),
38
+
extra_data: self.extra_data.into_static(),
39
+
}
40
+
}
41
+
}
42
+
25
43
impl jacquard_common::types::xrpc::XrpcRequest for FetchLabels {
26
44
const NSID: &'static str = "com.atproto.temp.fetchLabels";
27
45
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
28
46
const OUTPUT_ENCODING: &'static str = "application/json";
29
47
type Output<'de> = FetchLabelsOutput<'de>;
30
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
48
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
31
49
}
+11
-1
crates/jacquard-api/src/com_atproto/temp/request_phone_verification.rs
+11
-1
crates/jacquard-api/src/com_atproto/temp/request_phone_verification.rs
···
13
13
pub phone_number: jacquard_common::CowStr<'a>,
14
14
}
15
15
16
+
impl jacquard_common::IntoStatic for RequestPhoneVerification<'_> {
17
+
type Output = RequestPhoneVerification<'static>;
18
+
fn into_static(self) -> Self::Output {
19
+
RequestPhoneVerification {
20
+
phone_number: self.phone_number.into_static(),
21
+
extra_data: self.extra_data.into_static(),
22
+
}
23
+
}
24
+
}
25
+
16
26
impl jacquard_common::types::xrpc::XrpcRequest for RequestPhoneVerification<'_> {
17
27
const NSID: &'static str = "com.atproto.temp.requestPhoneVerification";
18
28
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
20
30
);
21
31
const OUTPUT_ENCODING: &'static str = "application/json";
22
32
type Output<'de> = ();
23
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
33
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
24
34
}
+11
-1
crates/jacquard-api/src/com_atproto/temp/revoke_account_credentials.rs
+11
-1
crates/jacquard-api/src/com_atproto/temp/revoke_account_credentials.rs
···
13
13
pub account: jacquard_common::types::ident::AtIdentifier<'a>,
14
14
}
15
15
16
+
impl jacquard_common::IntoStatic for RevokeAccountCredentials<'_> {
17
+
type Output = RevokeAccountCredentials<'static>;
18
+
fn into_static(self) -> Self::Output {
19
+
RevokeAccountCredentials {
20
+
account: self.account.into_static(),
21
+
extra_data: self.extra_data.into_static(),
22
+
}
23
+
}
24
+
}
25
+
16
26
impl jacquard_common::types::xrpc::XrpcRequest for RevokeAccountCredentials<'_> {
17
27
const NSID: &'static str = "com.atproto.temp.revokeAccountCredentials";
18
28
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
20
30
);
21
31
const OUTPUT_ENCODING: &'static str = "application/json";
22
32
type Output<'de> = ();
23
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
33
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
24
34
}
+18
crates/jacquard-api/src/tools_ozone/communication.rs
+18
crates/jacquard-api/src/tools_ozone/communication.rs
···
35
35
#[serde(borrow)]
36
36
pub subject: std::option::Option<jacquard_common::CowStr<'a>>,
37
37
pub updated_at: jacquard_common::types::string::Datetime,
38
+
}
39
+
40
+
impl jacquard_common::IntoStatic for TemplateView<'_> {
41
+
type Output = TemplateView<'static>;
42
+
fn into_static(self) -> Self::Output {
43
+
TemplateView {
44
+
content_markdown: self.content_markdown.into_static(),
45
+
created_at: self.created_at.into_static(),
46
+
disabled: self.disabled.into_static(),
47
+
id: self.id.into_static(),
48
+
lang: self.lang.into_static(),
49
+
last_updated_by: self.last_updated_by.into_static(),
50
+
name: self.name.into_static(),
51
+
subject: self.subject.into_static(),
52
+
updated_at: self.updated_at.into_static(),
53
+
extra_data: self.extra_data.into_static(),
54
+
}
55
+
}
38
56
}
+38
crates/jacquard-api/src/tools_ozone/communication/create_template.rs
+38
crates/jacquard-api/src/tools_ozone/communication/create_template.rs
···
27
27
pub subject: jacquard_common::CowStr<'a>,
28
28
}
29
29
30
+
impl jacquard_common::IntoStatic for CreateTemplate<'_> {
31
+
type Output = CreateTemplate<'static>;
32
+
fn into_static(self) -> Self::Output {
33
+
CreateTemplate {
34
+
content_markdown: self.content_markdown.into_static(),
35
+
created_by: self.created_by.into_static(),
36
+
lang: self.lang.into_static(),
37
+
name: self.name.into_static(),
38
+
subject: self.subject.into_static(),
39
+
extra_data: self.extra_data.into_static(),
40
+
}
41
+
}
42
+
}
43
+
30
44
#[jacquard_derive::lexicon]
31
45
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
32
46
#[serde(rename_all = "camelCase")]
···
36
50
pub value: crate::tools_ozone::communication::TemplateView<'a>,
37
51
}
38
52
53
+
impl jacquard_common::IntoStatic for CreateTemplateOutput<'_> {
54
+
type Output = CreateTemplateOutput<'static>;
55
+
fn into_static(self) -> Self::Output {
56
+
CreateTemplateOutput {
57
+
value: self.value.into_static(),
58
+
extra_data: self.extra_data.into_static(),
59
+
}
60
+
}
61
+
}
62
+
39
63
#[jacquard_derive::open_union]
40
64
#[derive(
41
65
serde::Serialize,
···
65
89
Ok(())
66
90
}
67
91
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
92
+
}
93
+
}
94
+
}
95
+
96
+
impl jacquard_common::IntoStatic for CreateTemplateError<'_> {
97
+
type Output = CreateTemplateError<'static>;
98
+
fn into_static(self) -> Self::Output {
99
+
match self {
100
+
CreateTemplateError::DuplicateTemplateName(v) => {
101
+
CreateTemplateError::DuplicateTemplateName(v.into_static())
102
+
}
103
+
CreateTemplateError::Unknown(v) => {
104
+
CreateTemplateError::Unknown(v.into_static())
105
+
}
68
106
}
69
107
}
70
108
}
+11
-1
crates/jacquard-api/src/tools_ozone/communication/delete_template.rs
+11
-1
crates/jacquard-api/src/tools_ozone/communication/delete_template.rs
···
13
13
pub id: jacquard_common::CowStr<'a>,
14
14
}
15
15
16
+
impl jacquard_common::IntoStatic for DeleteTemplate<'_> {
17
+
type Output = DeleteTemplate<'static>;
18
+
fn into_static(self) -> Self::Output {
19
+
DeleteTemplate {
20
+
id: self.id.into_static(),
21
+
extra_data: self.extra_data.into_static(),
22
+
}
23
+
}
24
+
}
25
+
16
26
impl jacquard_common::types::xrpc::XrpcRequest for DeleteTemplate<'_> {
17
27
const NSID: &'static str = "tools.ozone.communication.deleteTemplate";
18
28
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
20
30
);
21
31
const OUTPUT_ENCODING: &'static str = "application/json";
22
32
type Output<'de> = ();
23
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
33
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
24
34
}
+11
-1
crates/jacquard-api/src/tools_ozone/communication/list_templates.rs
+11
-1
crates/jacquard-api/src/tools_ozone/communication/list_templates.rs
···
15
15
>,
16
16
}
17
17
18
+
impl jacquard_common::IntoStatic for ListTemplatesOutput<'_> {
19
+
type Output = ListTemplatesOutput<'static>;
20
+
fn into_static(self) -> Self::Output {
21
+
ListTemplatesOutput {
22
+
communication_templates: self.communication_templates.into_static(),
23
+
extra_data: self.extra_data.into_static(),
24
+
}
25
+
}
26
+
}
27
+
18
28
/// XRPC request marker type
19
29
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]
20
30
pub struct ListTemplates;
···
23
33
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
24
34
const OUTPUT_ENCODING: &'static str = "application/json";
25
35
type Output<'de> = ListTemplatesOutput<'de>;
26
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
36
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
27
37
}
+40
crates/jacquard-api/src/tools_ozone/communication/update_template.rs
+40
crates/jacquard-api/src/tools_ozone/communication/update_template.rs
···
35
35
pub updated_by: std::option::Option<jacquard_common::types::string::Did<'a>>,
36
36
}
37
37
38
+
impl jacquard_common::IntoStatic for UpdateTemplate<'_> {
39
+
type Output = UpdateTemplate<'static>;
40
+
fn into_static(self) -> Self::Output {
41
+
UpdateTemplate {
42
+
content_markdown: self.content_markdown.into_static(),
43
+
disabled: self.disabled.into_static(),
44
+
id: self.id.into_static(),
45
+
lang: self.lang.into_static(),
46
+
name: self.name.into_static(),
47
+
subject: self.subject.into_static(),
48
+
updated_by: self.updated_by.into_static(),
49
+
extra_data: self.extra_data.into_static(),
50
+
}
51
+
}
52
+
}
53
+
38
54
#[jacquard_derive::lexicon]
39
55
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
40
56
#[serde(rename_all = "camelCase")]
···
44
60
pub value: crate::tools_ozone::communication::TemplateView<'a>,
45
61
}
46
62
63
+
impl jacquard_common::IntoStatic for UpdateTemplateOutput<'_> {
64
+
type Output = UpdateTemplateOutput<'static>;
65
+
fn into_static(self) -> Self::Output {
66
+
UpdateTemplateOutput {
67
+
value: self.value.into_static(),
68
+
extra_data: self.extra_data.into_static(),
69
+
}
70
+
}
71
+
}
72
+
47
73
#[jacquard_derive::open_union]
48
74
#[derive(
49
75
serde::Serialize,
···
73
99
Ok(())
74
100
}
75
101
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
102
+
}
103
+
}
104
+
}
105
+
106
+
impl jacquard_common::IntoStatic for UpdateTemplateError<'_> {
107
+
type Output = UpdateTemplateError<'static>;
108
+
fn into_static(self) -> Self::Output {
109
+
match self {
110
+
UpdateTemplateError::DuplicateTemplateName(v) => {
111
+
UpdateTemplateError::DuplicateTemplateName(v.into_static())
112
+
}
113
+
UpdateTemplateError::Unknown(v) => {
114
+
UpdateTemplateError::Unknown(v.into_static())
115
+
}
76
116
}
77
117
}
78
118
}
+95
-10
crates/jacquard-api/src/tools_ozone/hosting/get_account_history.rs
+95
-10
crates/jacquard-api/src/tools_ozone/hosting/get_account_history.rs
···
17
17
pub handle: std::option::Option<jacquard_common::types::string::Handle<'a>>,
18
18
}
19
19
20
+
impl jacquard_common::IntoStatic for AccountCreated<'_> {
21
+
type Output = AccountCreated<'static>;
22
+
fn into_static(self) -> Self::Output {
23
+
AccountCreated {
24
+
email: self.email.into_static(),
25
+
handle: self.handle.into_static(),
26
+
extra_data: self.extra_data.into_static(),
27
+
}
28
+
}
29
+
}
30
+
20
31
#[jacquard_derive::lexicon]
21
32
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
22
33
#[serde(rename_all = "camelCase")]
···
25
36
pub email: jacquard_common::CowStr<'a>,
26
37
}
27
38
39
+
impl jacquard_common::IntoStatic for EmailConfirmed<'_> {
40
+
type Output = EmailConfirmed<'static>;
41
+
fn into_static(self) -> Self::Output {
42
+
EmailConfirmed {
43
+
email: self.email.into_static(),
44
+
extra_data: self.extra_data.into_static(),
45
+
}
46
+
}
47
+
}
48
+
28
49
#[jacquard_derive::lexicon]
29
50
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
30
51
#[serde(rename_all = "camelCase")]
···
33
54
pub email: jacquard_common::CowStr<'a>,
34
55
}
35
56
57
+
impl jacquard_common::IntoStatic for EmailUpdated<'_> {
58
+
type Output = EmailUpdated<'static>;
59
+
fn into_static(self) -> Self::Output {
60
+
EmailUpdated {
61
+
email: self.email.into_static(),
62
+
extra_data: self.extra_data.into_static(),
63
+
}
64
+
}
65
+
}
66
+
36
67
#[jacquard_derive::lexicon]
37
68
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
38
69
#[serde(rename_all = "camelCase")]
···
49
80
#[serde(tag = "$type")]
50
81
#[serde(bound(deserialize = "'de: 'a"))]
51
82
pub enum EventRecordDetails<'a> {}
83
+
impl jacquard_common::IntoStatic for EventRecordDetails<'_> {
84
+
type Output = EventRecordDetails<'static>;
85
+
fn into_static(self) -> Self::Output {
86
+
match self {
87
+
EventRecordDetails::Unknown(v) => {
88
+
EventRecordDetails::Unknown(v.into_static())
89
+
}
90
+
}
91
+
}
92
+
}
93
+
94
+
impl jacquard_common::IntoStatic for Event<'_> {
95
+
type Output = Event<'static>;
96
+
fn into_static(self) -> Self::Output {
97
+
Event {
98
+
created_at: self.created_at.into_static(),
99
+
created_by: self.created_by.into_static(),
100
+
details: self.details.into_static(),
101
+
extra_data: self.extra_data.into_static(),
102
+
}
103
+
}
104
+
}
105
+
52
106
#[jacquard_derive::lexicon]
53
107
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
54
108
#[serde(rename_all = "camelCase")]
···
57
111
pub handle: jacquard_common::types::string::Handle<'a>,
58
112
}
59
113
60
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
114
+
impl jacquard_common::IntoStatic for HandleUpdated<'_> {
115
+
type Output = HandleUpdated<'static>;
116
+
fn into_static(self) -> Self::Output {
117
+
HandleUpdated {
118
+
handle: self.handle.into_static(),
119
+
extra_data: self.extra_data.into_static(),
120
+
}
121
+
}
122
+
}
123
+
124
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
61
125
#[serde(rename_all = "camelCase")]
62
126
pub struct GetAccountHistory<'a> {
63
127
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
68
132
#[serde(skip_serializing_if = "std::option::Option::is_none")]
69
133
#[serde(borrow)]
70
134
pub events: std::option::Option<Vec<jacquard_common::CowStr<'a>>>,
135
+
///(default: 50, min: 1, max: 100)
71
136
#[serde(skip_serializing_if = "std::option::Option::is_none")]
72
137
pub limit: std::option::Option<i64>,
73
138
}
74
139
75
-
impl Default for GetAccountHistory<'_> {
76
-
fn default() -> Self {
77
-
Self {
78
-
cursor: Default::default(),
79
-
did: Default::default(),
80
-
events: Default::default(),
81
-
limit: Some(50i64),
140
+
impl jacquard_common::IntoStatic for GetAccountHistory<'_> {
141
+
type Output = GetAccountHistory<'static>;
142
+
fn into_static(self) -> Self::Output {
143
+
GetAccountHistory {
144
+
cursor: self.cursor.into_static(),
145
+
did: self.did.into_static(),
146
+
events: self.events.into_static(),
147
+
limit: self.limit.into_static(),
82
148
}
83
149
}
84
150
}
···
94
160
pub events: Vec<jacquard_common::types::value::Data<'a>>,
95
161
}
96
162
163
+
impl jacquard_common::IntoStatic for GetAccountHistoryOutput<'_> {
164
+
type Output = GetAccountHistoryOutput<'static>;
165
+
fn into_static(self) -> Self::Output {
166
+
GetAccountHistoryOutput {
167
+
cursor: self.cursor.into_static(),
168
+
events: self.events.into_static(),
169
+
extra_data: self.extra_data.into_static(),
170
+
}
171
+
}
172
+
}
173
+
97
174
impl jacquard_common::types::xrpc::XrpcRequest for GetAccountHistory<'_> {
98
175
const NSID: &'static str = "tools.ozone.hosting.getAccountHistory";
99
176
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
100
177
const OUTPUT_ENCODING: &'static str = "application/json";
101
178
type Output<'de> = GetAccountHistoryOutput<'de>;
102
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
179
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
103
180
}
104
181
105
182
#[jacquard_derive::lexicon]
106
183
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
107
184
#[serde(rename_all = "camelCase")]
108
-
pub struct PasswordUpdated<'a> {}
185
+
pub struct PasswordUpdated<'a> {}
186
+
impl jacquard_common::IntoStatic for PasswordUpdated<'_> {
187
+
type Output = PasswordUpdated<'static>;
188
+
fn into_static(self) -> Self::Output {
189
+
PasswordUpdated {
190
+
extra_data: self.extra_data.into_static(),
191
+
}
192
+
}
193
+
}
+701
crates/jacquard-api/src/tools_ozone/moderation.rs
+701
crates/jacquard-api/src/tools_ozone/moderation.rs
···
34
34
pub timestamp: jacquard_common::types::string::Datetime,
35
35
}
36
36
37
+
impl jacquard_common::IntoStatic for AccountEvent<'_> {
38
+
type Output = AccountEvent<'static>;
39
+
fn into_static(self) -> Self::Output {
40
+
AccountEvent {
41
+
active: self.active.into_static(),
42
+
comment: self.comment.into_static(),
43
+
status: self.status.into_static(),
44
+
timestamp: self.timestamp.into_static(),
45
+
extra_data: self.extra_data.into_static(),
46
+
}
47
+
}
48
+
}
49
+
37
50
#[jacquard_derive::lexicon]
38
51
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
39
52
#[serde(rename_all = "camelCase")]
···
52
65
pub updated_at: std::option::Option<jacquard_common::types::string::Datetime>,
53
66
}
54
67
68
+
impl jacquard_common::IntoStatic for AccountHosting<'_> {
69
+
type Output = AccountHosting<'static>;
70
+
fn into_static(self) -> Self::Output {
71
+
AccountHosting {
72
+
created_at: self.created_at.into_static(),
73
+
deactivated_at: self.deactivated_at.into_static(),
74
+
deleted_at: self.deleted_at.into_static(),
75
+
reactivated_at: self.reactivated_at.into_static(),
76
+
status: self.status.into_static(),
77
+
updated_at: self.updated_at.into_static(),
78
+
extra_data: self.extra_data.into_static(),
79
+
}
80
+
}
81
+
}
82
+
55
83
///Statistics about a particular account subject
56
84
#[jacquard_derive::lexicon]
57
85
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
74
102
pub takedown_count: std::option::Option<i64>,
75
103
}
76
104
105
+
impl jacquard_common::IntoStatic for AccountStats<'_> {
106
+
type Output = AccountStats<'static>;
107
+
fn into_static(self) -> Self::Output {
108
+
AccountStats {
109
+
appeal_count: self.appeal_count.into_static(),
110
+
escalate_count: self.escalate_count.into_static(),
111
+
report_count: self.report_count.into_static(),
112
+
suspend_count: self.suspend_count.into_static(),
113
+
takedown_count: self.takedown_count.into_static(),
114
+
extra_data: self.extra_data.into_static(),
115
+
}
116
+
}
117
+
}
118
+
77
119
///Age assurance info coming directly from users. Only works on DID subjects.
78
120
#[jacquard_derive::lexicon]
79
121
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
105
147
pub status: jacquard_common::CowStr<'a>,
106
148
}
107
149
150
+
impl jacquard_common::IntoStatic for AgeAssuranceEvent<'_> {
151
+
type Output = AgeAssuranceEvent<'static>;
152
+
fn into_static(self) -> Self::Output {
153
+
AgeAssuranceEvent {
154
+
attempt_id: self.attempt_id.into_static(),
155
+
complete_ip: self.complete_ip.into_static(),
156
+
complete_ua: self.complete_ua.into_static(),
157
+
created_at: self.created_at.into_static(),
158
+
init_ip: self.init_ip.into_static(),
159
+
init_ua: self.init_ua.into_static(),
160
+
status: self.status.into_static(),
161
+
extra_data: self.extra_data.into_static(),
162
+
}
163
+
}
164
+
}
165
+
108
166
///Age assurance status override by moderators. Only works on DID subjects.
109
167
#[jacquard_derive::lexicon]
110
168
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
118
176
pub status: jacquard_common::CowStr<'a>,
119
177
}
120
178
179
+
impl jacquard_common::IntoStatic for AgeAssuranceOverrideEvent<'_> {
180
+
type Output = AgeAssuranceOverrideEvent<'static>;
181
+
fn into_static(self) -> Self::Output {
182
+
AgeAssuranceOverrideEvent {
183
+
comment: self.comment.into_static(),
184
+
status: self.status.into_static(),
185
+
extra_data: self.extra_data.into_static(),
186
+
}
187
+
}
188
+
}
189
+
121
190
#[jacquard_derive::lexicon]
122
191
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
123
192
#[serde(rename_all = "camelCase")]
···
141
210
#[serde(tag = "$type")]
142
211
#[serde(bound(deserialize = "'de: 'a"))]
143
212
pub enum BlobViewRecordDetails<'a> {}
213
+
impl jacquard_common::IntoStatic for BlobViewRecordDetails<'_> {
214
+
type Output = BlobViewRecordDetails<'static>;
215
+
fn into_static(self) -> Self::Output {
216
+
match self {
217
+
BlobViewRecordDetails::Unknown(v) => {
218
+
BlobViewRecordDetails::Unknown(v.into_static())
219
+
}
220
+
}
221
+
}
222
+
}
223
+
224
+
impl jacquard_common::IntoStatic for BlobView<'_> {
225
+
type Output = BlobView<'static>;
226
+
fn into_static(self) -> Self::Output {
227
+
BlobView {
228
+
cid: self.cid.into_static(),
229
+
created_at: self.created_at.into_static(),
230
+
details: self.details.into_static(),
231
+
mime_type: self.mime_type.into_static(),
232
+
moderation: self.moderation.into_static(),
233
+
size: self.size.into_static(),
234
+
extra_data: self.extra_data.into_static(),
235
+
}
236
+
}
237
+
}
238
+
144
239
///Logs identity related events on a repo subject. Normally captured by automod from the firehose and emitted to ozone for historical tracking.
145
240
#[jacquard_derive::lexicon]
146
241
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
160
255
pub tombstone: std::option::Option<bool>,
161
256
}
162
257
258
+
impl jacquard_common::IntoStatic for IdentityEvent<'_> {
259
+
type Output = IdentityEvent<'static>;
260
+
fn into_static(self) -> Self::Output {
261
+
IdentityEvent {
262
+
comment: self.comment.into_static(),
263
+
handle: self.handle.into_static(),
264
+
pds_host: self.pds_host.into_static(),
265
+
timestamp: self.timestamp.into_static(),
266
+
tombstone: self.tombstone.into_static(),
267
+
extra_data: self.extra_data.into_static(),
268
+
}
269
+
}
270
+
}
271
+
163
272
#[jacquard_derive::lexicon]
164
273
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
165
274
#[serde(rename_all = "camelCase")]
···
168
277
pub width: i64,
169
278
}
170
279
280
+
impl jacquard_common::IntoStatic for ImageDetails<'_> {
281
+
type Output = ImageDetails<'static>;
282
+
fn into_static(self) -> Self::Output {
283
+
ImageDetails {
284
+
height: self.height.into_static(),
285
+
width: self.width.into_static(),
286
+
extra_data: self.extra_data.into_static(),
287
+
}
288
+
}
289
+
}
290
+
171
291
#[jacquard_derive::lexicon]
172
292
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
173
293
#[serde(rename_all = "camelCase")]
···
180
300
pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
181
301
}
182
302
303
+
impl jacquard_common::IntoStatic for ModEventAcknowledge<'_> {
304
+
type Output = ModEventAcknowledge<'static>;
305
+
fn into_static(self) -> Self::Output {
306
+
ModEventAcknowledge {
307
+
acknowledge_account_subjects: self
308
+
.acknowledge_account_subjects
309
+
.into_static(),
310
+
comment: self.comment.into_static(),
311
+
extra_data: self.extra_data.into_static(),
312
+
}
313
+
}
314
+
}
315
+
183
316
///Add a comment to a subject. An empty comment will clear any previously set sticky comment.
184
317
#[jacquard_derive::lexicon]
185
318
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
193
326
pub sticky: std::option::Option<bool>,
194
327
}
195
328
329
+
impl jacquard_common::IntoStatic for ModEventComment<'_> {
330
+
type Output = ModEventComment<'static>;
331
+
fn into_static(self) -> Self::Output {
332
+
ModEventComment {
333
+
comment: self.comment.into_static(),
334
+
sticky: self.sticky.into_static(),
335
+
extra_data: self.extra_data.into_static(),
336
+
}
337
+
}
338
+
}
339
+
196
340
///Divert a record's blobs to a 3rd party service for further scanning/tagging
197
341
#[jacquard_derive::lexicon]
198
342
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
201
345
#[serde(skip_serializing_if = "std::option::Option::is_none")]
202
346
#[serde(borrow)]
203
347
pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
348
+
}
349
+
350
+
impl jacquard_common::IntoStatic for ModEventDivert<'_> {
351
+
type Output = ModEventDivert<'static>;
352
+
fn into_static(self) -> Self::Output {
353
+
ModEventDivert {
354
+
comment: self.comment.into_static(),
355
+
extra_data: self.extra_data.into_static(),
356
+
}
357
+
}
204
358
}
205
359
206
360
///Keep a log of outgoing email to a user
···
221
375
pub subject_line: jacquard_common::CowStr<'a>,
222
376
}
223
377
378
+
impl jacquard_common::IntoStatic for ModEventEmail<'_> {
379
+
type Output = ModEventEmail<'static>;
380
+
fn into_static(self) -> Self::Output {
381
+
ModEventEmail {
382
+
comment: self.comment.into_static(),
383
+
content: self.content.into_static(),
384
+
subject_line: self.subject_line.into_static(),
385
+
extra_data: self.extra_data.into_static(),
386
+
}
387
+
}
388
+
}
389
+
224
390
#[jacquard_derive::lexicon]
225
391
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
226
392
#[serde(rename_all = "camelCase")]
···
228
394
#[serde(skip_serializing_if = "std::option::Option::is_none")]
229
395
#[serde(borrow)]
230
396
pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
397
+
}
398
+
399
+
impl jacquard_common::IntoStatic for ModEventEscalate<'_> {
400
+
type Output = ModEventEscalate<'static>;
401
+
fn into_static(self) -> Self::Output {
402
+
ModEventEscalate {
403
+
comment: self.comment.into_static(),
404
+
extra_data: self.extra_data.into_static(),
405
+
}
406
+
}
231
407
}
232
408
233
409
///Apply/Negate labels on a subject
···
247
423
pub negate_label_vals: Vec<jacquard_common::CowStr<'a>>,
248
424
}
249
425
426
+
impl jacquard_common::IntoStatic for ModEventLabel<'_> {
427
+
type Output = ModEventLabel<'static>;
428
+
fn into_static(self) -> Self::Output {
429
+
ModEventLabel {
430
+
comment: self.comment.into_static(),
431
+
create_label_vals: self.create_label_vals.into_static(),
432
+
duration_in_hours: self.duration_in_hours.into_static(),
433
+
negate_label_vals: self.negate_label_vals.into_static(),
434
+
extra_data: self.extra_data.into_static(),
435
+
}
436
+
}
437
+
}
438
+
250
439
///Mute incoming reports on a subject
251
440
#[jacquard_derive::lexicon]
252
441
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
259
448
pub duration_in_hours: i64,
260
449
}
261
450
451
+
impl jacquard_common::IntoStatic for ModEventMute<'_> {
452
+
type Output = ModEventMute<'static>;
453
+
fn into_static(self) -> Self::Output {
454
+
ModEventMute {
455
+
comment: self.comment.into_static(),
456
+
duration_in_hours: self.duration_in_hours.into_static(),
457
+
extra_data: self.extra_data.into_static(),
458
+
}
459
+
}
460
+
}
461
+
262
462
///Mute incoming reports from an account
263
463
#[jacquard_derive::lexicon]
264
464
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
272
472
pub duration_in_hours: std::option::Option<i64>,
273
473
}
274
474
475
+
impl jacquard_common::IntoStatic for ModEventMuteReporter<'_> {
476
+
type Output = ModEventMuteReporter<'static>;
477
+
fn into_static(self) -> Self::Output {
478
+
ModEventMuteReporter {
479
+
comment: self.comment.into_static(),
480
+
duration_in_hours: self.duration_in_hours.into_static(),
481
+
extra_data: self.extra_data.into_static(),
482
+
}
483
+
}
484
+
}
485
+
275
486
///Set priority score of the subject. Higher score means higher priority.
276
487
#[jacquard_derive::lexicon]
277
488
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
283
494
pub score: i64,
284
495
}
285
496
497
+
impl jacquard_common::IntoStatic for ModEventPriorityScore<'_> {
498
+
type Output = ModEventPriorityScore<'static>;
499
+
fn into_static(self) -> Self::Output {
500
+
ModEventPriorityScore {
501
+
comment: self.comment.into_static(),
502
+
score: self.score.into_static(),
503
+
extra_data: self.extra_data.into_static(),
504
+
}
505
+
}
506
+
}
507
+
286
508
///Report a subject
287
509
#[jacquard_derive::lexicon]
288
510
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
298
520
pub report_type: crate::com_atproto::moderation::ReasonType<'a>,
299
521
}
300
522
523
+
impl jacquard_common::IntoStatic for ModEventReport<'_> {
524
+
type Output = ModEventReport<'static>;
525
+
fn into_static(self) -> Self::Output {
526
+
ModEventReport {
527
+
comment: self.comment.into_static(),
528
+
is_reporter_muted: self.is_reporter_muted.into_static(),
529
+
report_type: self.report_type.into_static(),
530
+
extra_data: self.extra_data.into_static(),
531
+
}
532
+
}
533
+
}
534
+
301
535
///Resolve appeal on a subject
302
536
#[jacquard_derive::lexicon]
303
537
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
309
543
pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
310
544
}
311
545
546
+
impl jacquard_common::IntoStatic for ModEventResolveAppeal<'_> {
547
+
type Output = ModEventResolveAppeal<'static>;
548
+
fn into_static(self) -> Self::Output {
549
+
ModEventResolveAppeal {
550
+
comment: self.comment.into_static(),
551
+
extra_data: self.extra_data.into_static(),
552
+
}
553
+
}
554
+
}
555
+
312
556
///Revert take down action on a subject
313
557
#[jacquard_derive::lexicon]
314
558
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
320
564
pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
321
565
}
322
566
567
+
impl jacquard_common::IntoStatic for ModEventReverseTakedown<'_> {
568
+
type Output = ModEventReverseTakedown<'static>;
569
+
fn into_static(self) -> Self::Output {
570
+
ModEventReverseTakedown {
571
+
comment: self.comment.into_static(),
572
+
extra_data: self.extra_data.into_static(),
573
+
}
574
+
}
575
+
}
576
+
323
577
///Add/Remove a tag on a subject
324
578
#[jacquard_derive::lexicon]
325
579
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
337
591
pub remove: Vec<jacquard_common::CowStr<'a>>,
338
592
}
339
593
594
+
impl jacquard_common::IntoStatic for ModEventTag<'_> {
595
+
type Output = ModEventTag<'static>;
596
+
fn into_static(self) -> Self::Output {
597
+
ModEventTag {
598
+
add: self.add.into_static(),
599
+
comment: self.comment.into_static(),
600
+
remove: self.remove.into_static(),
601
+
extra_data: self.extra_data.into_static(),
602
+
}
603
+
}
604
+
}
605
+
340
606
///Take down a subject permanently or temporarily
341
607
#[jacquard_derive::lexicon]
342
608
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
357
623
pub policies: std::option::Option<Vec<jacquard_common::CowStr<'a>>>,
358
624
}
359
625
626
+
impl jacquard_common::IntoStatic for ModEventTakedown<'_> {
627
+
type Output = ModEventTakedown<'static>;
628
+
fn into_static(self) -> Self::Output {
629
+
ModEventTakedown {
630
+
acknowledge_account_subjects: self
631
+
.acknowledge_account_subjects
632
+
.into_static(),
633
+
comment: self.comment.into_static(),
634
+
duration_in_hours: self.duration_in_hours.into_static(),
635
+
policies: self.policies.into_static(),
636
+
extra_data: self.extra_data.into_static(),
637
+
}
638
+
}
639
+
}
640
+
360
641
///Unmute action on a subject
361
642
#[jacquard_derive::lexicon]
362
643
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
368
649
pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
369
650
}
370
651
652
+
impl jacquard_common::IntoStatic for ModEventUnmute<'_> {
653
+
type Output = ModEventUnmute<'static>;
654
+
fn into_static(self) -> Self::Output {
655
+
ModEventUnmute {
656
+
comment: self.comment.into_static(),
657
+
extra_data: self.extra_data.into_static(),
658
+
}
659
+
}
660
+
}
661
+
371
662
///Unmute incoming reports from an account
372
663
#[jacquard_derive::lexicon]
373
664
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
377
668
#[serde(skip_serializing_if = "std::option::Option::is_none")]
378
669
#[serde(borrow)]
379
670
pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
671
+
}
672
+
673
+
impl jacquard_common::IntoStatic for ModEventUnmuteReporter<'_> {
674
+
type Output = ModEventUnmuteReporter<'static>;
675
+
fn into_static(self) -> Self::Output {
676
+
ModEventUnmuteReporter {
677
+
comment: self.comment.into_static(),
678
+
extra_data: self.extra_data.into_static(),
679
+
}
680
+
}
380
681
}
381
682
382
683
#[jacquard_derive::lexicon]
···
409
710
#[serde(tag = "$type")]
410
711
#[serde(bound(deserialize = "'de: 'a"))]
411
712
pub enum ModEventViewRecordEvent<'a> {}
713
+
impl jacquard_common::IntoStatic for ModEventViewRecordEvent<'_> {
714
+
type Output = ModEventViewRecordEvent<'static>;
715
+
fn into_static(self) -> Self::Output {
716
+
match self {
717
+
ModEventViewRecordEvent::Unknown(v) => {
718
+
ModEventViewRecordEvent::Unknown(v.into_static())
719
+
}
720
+
}
721
+
}
722
+
}
723
+
412
724
#[jacquard_derive::open_union]
413
725
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
414
726
#[serde(tag = "$type")]
···
422
734
DefsMessageRef(Box<crate::chat_bsky::convo::MessageRef<'a>>),
423
735
}
424
736
737
+
impl jacquard_common::IntoStatic for ModEventViewRecordSubject<'_> {
738
+
type Output = ModEventViewRecordSubject<'static>;
739
+
fn into_static(self) -> Self::Output {
740
+
match self {
741
+
ModEventViewRecordSubject::DefsRepoRef(v) => {
742
+
ModEventViewRecordSubject::DefsRepoRef(v.into_static())
743
+
}
744
+
ModEventViewRecordSubject::StrongRef(v) => {
745
+
ModEventViewRecordSubject::StrongRef(v.into_static())
746
+
}
747
+
ModEventViewRecordSubject::DefsMessageRef(v) => {
748
+
ModEventViewRecordSubject::DefsMessageRef(v.into_static())
749
+
}
750
+
ModEventViewRecordSubject::Unknown(v) => {
751
+
ModEventViewRecordSubject::Unknown(v.into_static())
752
+
}
753
+
}
754
+
}
755
+
}
756
+
757
+
impl jacquard_common::IntoStatic for ModEventView<'_> {
758
+
type Output = ModEventView<'static>;
759
+
fn into_static(self) -> Self::Output {
760
+
ModEventView {
761
+
created_at: self.created_at.into_static(),
762
+
created_by: self.created_by.into_static(),
763
+
creator_handle: self.creator_handle.into_static(),
764
+
event: self.event.into_static(),
765
+
id: self.id.into_static(),
766
+
mod_tool: self.mod_tool.into_static(),
767
+
subject: self.subject.into_static(),
768
+
subject_blob_cids: self.subject_blob_cids.into_static(),
769
+
subject_handle: self.subject_handle.into_static(),
770
+
extra_data: self.extra_data.into_static(),
771
+
}
772
+
}
773
+
}
774
+
425
775
#[jacquard_derive::lexicon]
426
776
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
427
777
#[serde(rename_all = "camelCase")]
···
446
796
#[serde(tag = "$type")]
447
797
#[serde(bound(deserialize = "'de: 'a"))]
448
798
pub enum ModEventViewDetailRecordEvent<'a> {}
799
+
impl jacquard_common::IntoStatic for ModEventViewDetailRecordEvent<'_> {
800
+
type Output = ModEventViewDetailRecordEvent<'static>;
801
+
fn into_static(self) -> Self::Output {
802
+
match self {
803
+
ModEventViewDetailRecordEvent::Unknown(v) => {
804
+
ModEventViewDetailRecordEvent::Unknown(v.into_static())
805
+
}
806
+
}
807
+
}
808
+
}
809
+
449
810
#[jacquard_derive::open_union]
450
811
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
451
812
#[serde(tag = "$type")]
452
813
#[serde(bound(deserialize = "'de: 'a"))]
453
814
pub enum ModEventViewDetailRecordSubject<'a> {}
815
+
impl jacquard_common::IntoStatic for ModEventViewDetailRecordSubject<'_> {
816
+
type Output = ModEventViewDetailRecordSubject<'static>;
817
+
fn into_static(self) -> Self::Output {
818
+
match self {
819
+
ModEventViewDetailRecordSubject::Unknown(v) => {
820
+
ModEventViewDetailRecordSubject::Unknown(v.into_static())
821
+
}
822
+
}
823
+
}
824
+
}
825
+
826
+
impl jacquard_common::IntoStatic for ModEventViewDetail<'_> {
827
+
type Output = ModEventViewDetail<'static>;
828
+
fn into_static(self) -> Self::Output {
829
+
ModEventViewDetail {
830
+
created_at: self.created_at.into_static(),
831
+
created_by: self.created_by.into_static(),
832
+
event: self.event.into_static(),
833
+
id: self.id.into_static(),
834
+
mod_tool: self.mod_tool.into_static(),
835
+
subject: self.subject.into_static(),
836
+
subject_blobs: self.subject_blobs.into_static(),
837
+
extra_data: self.extra_data.into_static(),
838
+
}
839
+
}
840
+
}
841
+
454
842
///Moderation tool information for tracing the source of the action
455
843
#[jacquard_derive::lexicon]
456
844
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
465
853
pub name: jacquard_common::CowStr<'a>,
466
854
}
467
855
856
+
impl jacquard_common::IntoStatic for ModTool<'_> {
857
+
type Output = ModTool<'static>;
858
+
fn into_static(self) -> Self::Output {
859
+
ModTool {
860
+
meta: self.meta.into_static(),
861
+
name: self.name.into_static(),
862
+
extra_data: self.extra_data.into_static(),
863
+
}
864
+
}
865
+
}
866
+
468
867
#[jacquard_derive::lexicon]
469
868
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
470
869
#[serde(rename_all = "camelCase")]
···
476
875
>,
477
876
}
478
877
878
+
impl jacquard_common::IntoStatic for Moderation<'_> {
879
+
type Output = Moderation<'static>;
880
+
fn into_static(self) -> Self::Output {
881
+
Moderation {
882
+
subject_status: self.subject_status.into_static(),
883
+
extra_data: self.extra_data.into_static(),
884
+
}
885
+
}
886
+
}
887
+
479
888
#[jacquard_derive::lexicon]
480
889
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
481
890
#[serde(rename_all = "camelCase")]
···
487
896
>,
488
897
}
489
898
899
+
impl jacquard_common::IntoStatic for ModerationDetail<'_> {
900
+
type Output = ModerationDetail<'static>;
901
+
fn into_static(self) -> Self::Output {
902
+
ModerationDetail {
903
+
subject_status: self.subject_status.into_static(),
904
+
extra_data: self.extra_data.into_static(),
905
+
}
906
+
}
907
+
}
908
+
490
909
///Logs lifecycle event on a record subject. Normally captured by automod from the firehose and emitted to ozone for historical tracking.
491
910
#[jacquard_derive::lexicon]
492
911
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
503
922
pub timestamp: jacquard_common::types::string::Datetime,
504
923
}
505
924
925
+
impl jacquard_common::IntoStatic for RecordEvent<'_> {
926
+
type Output = RecordEvent<'static>;
927
+
fn into_static(self) -> Self::Output {
928
+
RecordEvent {
929
+
cid: self.cid.into_static(),
930
+
comment: self.comment.into_static(),
931
+
op: self.op.into_static(),
932
+
timestamp: self.timestamp.into_static(),
933
+
extra_data: self.extra_data.into_static(),
934
+
}
935
+
}
936
+
}
937
+
506
938
#[jacquard_derive::lexicon]
507
939
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
508
940
#[serde(rename_all = "camelCase")]
···
517
949
pub updated_at: std::option::Option<jacquard_common::types::string::Datetime>,
518
950
}
519
951
952
+
impl jacquard_common::IntoStatic for RecordHosting<'_> {
953
+
type Output = RecordHosting<'static>;
954
+
fn into_static(self) -> Self::Output {
955
+
RecordHosting {
956
+
created_at: self.created_at.into_static(),
957
+
deleted_at: self.deleted_at.into_static(),
958
+
status: self.status.into_static(),
959
+
updated_at: self.updated_at.into_static(),
960
+
extra_data: self.extra_data.into_static(),
961
+
}
962
+
}
963
+
}
964
+
520
965
#[jacquard_derive::lexicon]
521
966
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
522
967
#[serde(rename_all = "camelCase")]
···
534
979
pub uri: jacquard_common::types::string::AtUri<'a>,
535
980
#[serde(borrow)]
536
981
pub value: jacquard_common::types::value::Data<'a>,
982
+
}
983
+
984
+
impl jacquard_common::IntoStatic for RecordView<'_> {
985
+
type Output = RecordView<'static>;
986
+
fn into_static(self) -> Self::Output {
987
+
RecordView {
988
+
blob_cids: self.blob_cids.into_static(),
989
+
cid: self.cid.into_static(),
990
+
indexed_at: self.indexed_at.into_static(),
991
+
moderation: self.moderation.into_static(),
992
+
repo: self.repo.into_static(),
993
+
uri: self.uri.into_static(),
994
+
value: self.value.into_static(),
995
+
extra_data: self.extra_data.into_static(),
996
+
}
997
+
}
537
998
}
538
999
539
1000
#[jacquard_derive::lexicon]
···
558
1019
pub value: jacquard_common::types::value::Data<'a>,
559
1020
}
560
1021
1022
+
impl jacquard_common::IntoStatic for RecordViewDetail<'_> {
1023
+
type Output = RecordViewDetail<'static>;
1024
+
fn into_static(self) -> Self::Output {
1025
+
RecordViewDetail {
1026
+
blobs: self.blobs.into_static(),
1027
+
cid: self.cid.into_static(),
1028
+
indexed_at: self.indexed_at.into_static(),
1029
+
labels: self.labels.into_static(),
1030
+
moderation: self.moderation.into_static(),
1031
+
repo: self.repo.into_static(),
1032
+
uri: self.uri.into_static(),
1033
+
value: self.value.into_static(),
1034
+
extra_data: self.extra_data.into_static(),
1035
+
}
1036
+
}
1037
+
}
1038
+
561
1039
#[jacquard_derive::lexicon]
562
1040
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
563
1041
#[serde(rename_all = "camelCase")]
···
566
1044
pub uri: jacquard_common::types::string::AtUri<'a>,
567
1045
}
568
1046
1047
+
impl jacquard_common::IntoStatic for RecordViewNotFound<'_> {
1048
+
type Output = RecordViewNotFound<'static>;
1049
+
fn into_static(self) -> Self::Output {
1050
+
RecordViewNotFound {
1051
+
uri: self.uri.into_static(),
1052
+
extra_data: self.extra_data.into_static(),
1053
+
}
1054
+
}
1055
+
}
1056
+
569
1057
///Statistics about a set of record subject items
570
1058
#[jacquard_derive::lexicon]
571
1059
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
595
1083
///Cumulative sum of the number of reports on the items in the set
596
1084
#[serde(skip_serializing_if = "std::option::Option::is_none")]
597
1085
pub total_reports: std::option::Option<i64>,
1086
+
}
1087
+
1088
+
impl jacquard_common::IntoStatic for RecordsStats<'_> {
1089
+
type Output = RecordsStats<'static>;
1090
+
fn into_static(self) -> Self::Output {
1091
+
RecordsStats {
1092
+
appealed_count: self.appealed_count.into_static(),
1093
+
escalated_count: self.escalated_count.into_static(),
1094
+
pending_count: self.pending_count.into_static(),
1095
+
processed_count: self.processed_count.into_static(),
1096
+
reported_count: self.reported_count.into_static(),
1097
+
subject_count: self.subject_count.into_static(),
1098
+
takendown_count: self.takendown_count.into_static(),
1099
+
total_reports: self.total_reports.into_static(),
1100
+
extra_data: self.extra_data.into_static(),
1101
+
}
1102
+
}
598
1103
}
599
1104
600
1105
#[jacquard_derive::lexicon]
···
630
1135
>,
631
1136
}
632
1137
1138
+
impl jacquard_common::IntoStatic for RepoView<'_> {
1139
+
type Output = RepoView<'static>;
1140
+
fn into_static(self) -> Self::Output {
1141
+
RepoView {
1142
+
deactivated_at: self.deactivated_at.into_static(),
1143
+
did: self.did.into_static(),
1144
+
email: self.email.into_static(),
1145
+
handle: self.handle.into_static(),
1146
+
indexed_at: self.indexed_at.into_static(),
1147
+
invite_note: self.invite_note.into_static(),
1148
+
invited_by: self.invited_by.into_static(),
1149
+
invites_disabled: self.invites_disabled.into_static(),
1150
+
moderation: self.moderation.into_static(),
1151
+
related_records: self.related_records.into_static(),
1152
+
threat_signatures: self.threat_signatures.into_static(),
1153
+
extra_data: self.extra_data.into_static(),
1154
+
}
1155
+
}
1156
+
}
1157
+
633
1158
#[jacquard_derive::lexicon]
634
1159
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
635
1160
#[serde(rename_all = "camelCase")]
···
673
1198
>,
674
1199
}
675
1200
1201
+
impl jacquard_common::IntoStatic for RepoViewDetail<'_> {
1202
+
type Output = RepoViewDetail<'static>;
1203
+
fn into_static(self) -> Self::Output {
1204
+
RepoViewDetail {
1205
+
deactivated_at: self.deactivated_at.into_static(),
1206
+
did: self.did.into_static(),
1207
+
email: self.email.into_static(),
1208
+
email_confirmed_at: self.email_confirmed_at.into_static(),
1209
+
handle: self.handle.into_static(),
1210
+
indexed_at: self.indexed_at.into_static(),
1211
+
invite_note: self.invite_note.into_static(),
1212
+
invited_by: self.invited_by.into_static(),
1213
+
invites: self.invites.into_static(),
1214
+
invites_disabled: self.invites_disabled.into_static(),
1215
+
labels: self.labels.into_static(),
1216
+
moderation: self.moderation.into_static(),
1217
+
related_records: self.related_records.into_static(),
1218
+
threat_signatures: self.threat_signatures.into_static(),
1219
+
extra_data: self.extra_data.into_static(),
1220
+
}
1221
+
}
1222
+
}
1223
+
676
1224
#[jacquard_derive::lexicon]
677
1225
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
678
1226
#[serde(rename_all = "camelCase")]
···
681
1229
pub did: jacquard_common::types::string::Did<'a>,
682
1230
}
683
1231
1232
+
impl jacquard_common::IntoStatic for RepoViewNotFound<'_> {
1233
+
type Output = RepoViewNotFound<'static>;
1234
+
fn into_static(self) -> Self::Output {
1235
+
RepoViewNotFound {
1236
+
did: self.did.into_static(),
1237
+
extra_data: self.extra_data.into_static(),
1238
+
}
1239
+
}
1240
+
}
1241
+
684
1242
#[jacquard_derive::lexicon]
685
1243
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
686
1244
#[serde(rename_all = "camelCase")]
···
705
1263
pub takendown_record_count: i64,
706
1264
}
707
1265
1266
+
impl jacquard_common::IntoStatic for ReporterStats<'_> {
1267
+
type Output = ReporterStats<'static>;
1268
+
fn into_static(self) -> Self::Output {
1269
+
ReporterStats {
1270
+
account_report_count: self.account_report_count.into_static(),
1271
+
did: self.did.into_static(),
1272
+
labeled_account_count: self.labeled_account_count.into_static(),
1273
+
labeled_record_count: self.labeled_record_count.into_static(),
1274
+
record_report_count: self.record_report_count.into_static(),
1275
+
reported_account_count: self.reported_account_count.into_static(),
1276
+
reported_record_count: self.reported_record_count.into_static(),
1277
+
takendown_account_count: self.takendown_account_count.into_static(),
1278
+
takendown_record_count: self.takendown_record_count.into_static(),
1279
+
extra_data: self.extra_data.into_static(),
1280
+
}
1281
+
}
1282
+
}
1283
+
708
1284
///Account credentials revocation by moderators. Only works on DID subjects.
709
1285
#[jacquard_derive::lexicon]
710
1286
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
713
1289
///Comment describing the reason for the revocation.
714
1290
#[serde(borrow)]
715
1291
pub comment: jacquard_common::CowStr<'a>,
1292
+
}
1293
+
1294
+
impl jacquard_common::IntoStatic for RevokeAccountCredentialsEvent<'_> {
1295
+
type Output = RevokeAccountCredentialsEvent<'static>;
1296
+
fn into_static(self) -> Self::Output {
1297
+
RevokeAccountCredentialsEvent {
1298
+
comment: self.comment.into_static(),
1299
+
extra_data: self.extra_data.into_static(),
1300
+
}
1301
+
}
716
1302
}
717
1303
718
1304
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
···
788
1374
}
789
1375
}
790
1376
1377
+
impl jacquard_common::IntoStatic for SubjectReviewState<'_> {
1378
+
type Output = SubjectReviewState<'static>;
1379
+
fn into_static(self) -> Self::Output {
1380
+
match self {
1381
+
SubjectReviewState::ReviewOpen => SubjectReviewState::ReviewOpen,
1382
+
SubjectReviewState::ReviewEscalated => SubjectReviewState::ReviewEscalated,
1383
+
SubjectReviewState::ReviewClosed => SubjectReviewState::ReviewClosed,
1384
+
SubjectReviewState::ReviewNone => SubjectReviewState::ReviewNone,
1385
+
SubjectReviewState::Other(v) => SubjectReviewState::Other(v.into_static()),
1386
+
}
1387
+
}
1388
+
}
1389
+
791
1390
#[jacquard_derive::lexicon]
792
1391
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
793
1392
#[serde(rename_all = "camelCase")]
···
872
1471
#[serde(tag = "$type")]
873
1472
#[serde(bound(deserialize = "'de: 'a"))]
874
1473
pub enum SubjectStatusViewRecordHosting<'a> {}
1474
+
impl jacquard_common::IntoStatic for SubjectStatusViewRecordHosting<'_> {
1475
+
type Output = SubjectStatusViewRecordHosting<'static>;
1476
+
fn into_static(self) -> Self::Output {
1477
+
match self {
1478
+
SubjectStatusViewRecordHosting::Unknown(v) => {
1479
+
SubjectStatusViewRecordHosting::Unknown(v.into_static())
1480
+
}
1481
+
}
1482
+
}
1483
+
}
1484
+
875
1485
#[jacquard_derive::open_union]
876
1486
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
877
1487
#[serde(tag = "$type")]
···
885
1495
DefsMessageRef(Box<crate::chat_bsky::convo::MessageRef<'a>>),
886
1496
}
887
1497
1498
+
impl jacquard_common::IntoStatic for SubjectStatusViewRecordSubject<'_> {
1499
+
type Output = SubjectStatusViewRecordSubject<'static>;
1500
+
fn into_static(self) -> Self::Output {
1501
+
match self {
1502
+
SubjectStatusViewRecordSubject::DefsRepoRef(v) => {
1503
+
SubjectStatusViewRecordSubject::DefsRepoRef(v.into_static())
1504
+
}
1505
+
SubjectStatusViewRecordSubject::StrongRef(v) => {
1506
+
SubjectStatusViewRecordSubject::StrongRef(v.into_static())
1507
+
}
1508
+
SubjectStatusViewRecordSubject::DefsMessageRef(v) => {
1509
+
SubjectStatusViewRecordSubject::DefsMessageRef(v.into_static())
1510
+
}
1511
+
SubjectStatusViewRecordSubject::Unknown(v) => {
1512
+
SubjectStatusViewRecordSubject::Unknown(v.into_static())
1513
+
}
1514
+
}
1515
+
}
1516
+
}
1517
+
1518
+
impl jacquard_common::IntoStatic for SubjectStatusView<'_> {
1519
+
type Output = SubjectStatusView<'static>;
1520
+
fn into_static(self) -> Self::Output {
1521
+
SubjectStatusView {
1522
+
account_stats: self.account_stats.into_static(),
1523
+
age_assurance_state: self.age_assurance_state.into_static(),
1524
+
age_assurance_updated_by: self.age_assurance_updated_by.into_static(),
1525
+
appealed: self.appealed.into_static(),
1526
+
comment: self.comment.into_static(),
1527
+
created_at: self.created_at.into_static(),
1528
+
hosting: self.hosting.into_static(),
1529
+
id: self.id.into_static(),
1530
+
last_appealed_at: self.last_appealed_at.into_static(),
1531
+
last_reported_at: self.last_reported_at.into_static(),
1532
+
last_reviewed_at: self.last_reviewed_at.into_static(),
1533
+
last_reviewed_by: self.last_reviewed_by.into_static(),
1534
+
mute_reporting_until: self.mute_reporting_until.into_static(),
1535
+
mute_until: self.mute_until.into_static(),
1536
+
priority_score: self.priority_score.into_static(),
1537
+
records_stats: self.records_stats.into_static(),
1538
+
review_state: self.review_state.into_static(),
1539
+
subject: self.subject.into_static(),
1540
+
subject_blob_cids: self.subject_blob_cids.into_static(),
1541
+
subject_repo_handle: self.subject_repo_handle.into_static(),
1542
+
suspend_until: self.suspend_until.into_static(),
1543
+
tags: self.tags.into_static(),
1544
+
takendown: self.takendown.into_static(),
1545
+
updated_at: self.updated_at.into_static(),
1546
+
extra_data: self.extra_data.into_static(),
1547
+
}
1548
+
}
1549
+
}
1550
+
888
1551
///Detailed view of a subject. For record subjects, the author's repo and profile will be returned.
889
1552
#[jacquard_derive::lexicon]
890
1553
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
917
1580
#[serde(tag = "$type")]
918
1581
#[serde(bound(deserialize = "'de: 'a"))]
919
1582
pub enum SubjectViewRecordProfile<'a> {}
1583
+
impl jacquard_common::IntoStatic for SubjectViewRecordProfile<'_> {
1584
+
type Output = SubjectViewRecordProfile<'static>;
1585
+
fn into_static(self) -> Self::Output {
1586
+
match self {
1587
+
SubjectViewRecordProfile::Unknown(v) => {
1588
+
SubjectViewRecordProfile::Unknown(v.into_static())
1589
+
}
1590
+
}
1591
+
}
1592
+
}
1593
+
1594
+
impl jacquard_common::IntoStatic for SubjectView<'_> {
1595
+
type Output = SubjectView<'static>;
1596
+
fn into_static(self) -> Self::Output {
1597
+
SubjectView {
1598
+
profile: self.profile.into_static(),
1599
+
record: self.record.into_static(),
1600
+
repo: self.repo.into_static(),
1601
+
status: self.status.into_static(),
1602
+
subject: self.subject.into_static(),
1603
+
r#type: self.r#type.into_static(),
1604
+
extra_data: self.extra_data.into_static(),
1605
+
}
1606
+
}
1607
+
}
1608
+
920
1609
#[jacquard_derive::lexicon]
921
1610
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
922
1611
#[serde(rename_all = "camelCase")]
···
924
1613
pub height: i64,
925
1614
pub length: i64,
926
1615
pub width: i64,
1616
+
}
1617
+
1618
+
impl jacquard_common::IntoStatic for VideoDetails<'_> {
1619
+
type Output = VideoDetails<'static>;
1620
+
fn into_static(self) -> Self::Output {
1621
+
VideoDetails {
1622
+
height: self.height.into_static(),
1623
+
length: self.length.into_static(),
1624
+
width: self.width.into_static(),
1625
+
extra_data: self.extra_data.into_static(),
1626
+
}
1627
+
}
927
1628
}
+134
crates/jacquard-api/src/tools_ozone/moderation/emit_event.rs
+134
crates/jacquard-api/src/tools_ozone/moderation/emit_event.rs
···
96
96
),
97
97
}
98
98
99
+
impl jacquard_common::IntoStatic for EmitEventRecordEvent<'_> {
100
+
type Output = EmitEventRecordEvent<'static>;
101
+
fn into_static(self) -> Self::Output {
102
+
match self {
103
+
EmitEventRecordEvent::DefsModEventTakedown(v) => {
104
+
EmitEventRecordEvent::DefsModEventTakedown(v.into_static())
105
+
}
106
+
EmitEventRecordEvent::DefsModEventAcknowledge(v) => {
107
+
EmitEventRecordEvent::DefsModEventAcknowledge(v.into_static())
108
+
}
109
+
EmitEventRecordEvent::DefsModEventEscalate(v) => {
110
+
EmitEventRecordEvent::DefsModEventEscalate(v.into_static())
111
+
}
112
+
EmitEventRecordEvent::DefsModEventComment(v) => {
113
+
EmitEventRecordEvent::DefsModEventComment(v.into_static())
114
+
}
115
+
EmitEventRecordEvent::DefsModEventLabel(v) => {
116
+
EmitEventRecordEvent::DefsModEventLabel(v.into_static())
117
+
}
118
+
EmitEventRecordEvent::DefsModEventReport(v) => {
119
+
EmitEventRecordEvent::DefsModEventReport(v.into_static())
120
+
}
121
+
EmitEventRecordEvent::DefsModEventMute(v) => {
122
+
EmitEventRecordEvent::DefsModEventMute(v.into_static())
123
+
}
124
+
EmitEventRecordEvent::DefsModEventUnmute(v) => {
125
+
EmitEventRecordEvent::DefsModEventUnmute(v.into_static())
126
+
}
127
+
EmitEventRecordEvent::DefsModEventMuteReporter(v) => {
128
+
EmitEventRecordEvent::DefsModEventMuteReporter(v.into_static())
129
+
}
130
+
EmitEventRecordEvent::DefsModEventUnmuteReporter(v) => {
131
+
EmitEventRecordEvent::DefsModEventUnmuteReporter(v.into_static())
132
+
}
133
+
EmitEventRecordEvent::DefsModEventReverseTakedown(v) => {
134
+
EmitEventRecordEvent::DefsModEventReverseTakedown(v.into_static())
135
+
}
136
+
EmitEventRecordEvent::DefsModEventResolveAppeal(v) => {
137
+
EmitEventRecordEvent::DefsModEventResolveAppeal(v.into_static())
138
+
}
139
+
EmitEventRecordEvent::DefsModEventEmail(v) => {
140
+
EmitEventRecordEvent::DefsModEventEmail(v.into_static())
141
+
}
142
+
EmitEventRecordEvent::DefsModEventDivert(v) => {
143
+
EmitEventRecordEvent::DefsModEventDivert(v.into_static())
144
+
}
145
+
EmitEventRecordEvent::DefsModEventTag(v) => {
146
+
EmitEventRecordEvent::DefsModEventTag(v.into_static())
147
+
}
148
+
EmitEventRecordEvent::DefsAccountEvent(v) => {
149
+
EmitEventRecordEvent::DefsAccountEvent(v.into_static())
150
+
}
151
+
EmitEventRecordEvent::DefsIdentityEvent(v) => {
152
+
EmitEventRecordEvent::DefsIdentityEvent(v.into_static())
153
+
}
154
+
EmitEventRecordEvent::DefsRecordEvent(v) => {
155
+
EmitEventRecordEvent::DefsRecordEvent(v.into_static())
156
+
}
157
+
EmitEventRecordEvent::DefsModEventPriorityScore(v) => {
158
+
EmitEventRecordEvent::DefsModEventPriorityScore(v.into_static())
159
+
}
160
+
EmitEventRecordEvent::DefsAgeAssuranceEvent(v) => {
161
+
EmitEventRecordEvent::DefsAgeAssuranceEvent(v.into_static())
162
+
}
163
+
EmitEventRecordEvent::DefsAgeAssuranceOverrideEvent(v) => {
164
+
EmitEventRecordEvent::DefsAgeAssuranceOverrideEvent(v.into_static())
165
+
}
166
+
EmitEventRecordEvent::DefsRevokeAccountCredentialsEvent(v) => {
167
+
EmitEventRecordEvent::DefsRevokeAccountCredentialsEvent(v.into_static())
168
+
}
169
+
EmitEventRecordEvent::Unknown(v) => {
170
+
EmitEventRecordEvent::Unknown(v.into_static())
171
+
}
172
+
}
173
+
}
174
+
}
175
+
99
176
#[jacquard_derive::open_union]
100
177
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
101
178
#[serde(tag = "$type")]
···
107
184
StrongRef(Box<crate::com_atproto::repo::strong_ref::StrongRef<'a>>),
108
185
}
109
186
187
+
impl jacquard_common::IntoStatic for EmitEventRecordSubject<'_> {
188
+
type Output = EmitEventRecordSubject<'static>;
189
+
fn into_static(self) -> Self::Output {
190
+
match self {
191
+
EmitEventRecordSubject::DefsRepoRef(v) => {
192
+
EmitEventRecordSubject::DefsRepoRef(v.into_static())
193
+
}
194
+
EmitEventRecordSubject::StrongRef(v) => {
195
+
EmitEventRecordSubject::StrongRef(v.into_static())
196
+
}
197
+
EmitEventRecordSubject::Unknown(v) => {
198
+
EmitEventRecordSubject::Unknown(v.into_static())
199
+
}
200
+
}
201
+
}
202
+
}
203
+
204
+
impl jacquard_common::IntoStatic for EmitEvent<'_> {
205
+
type Output = EmitEvent<'static>;
206
+
fn into_static(self) -> Self::Output {
207
+
EmitEvent {
208
+
created_by: self.created_by.into_static(),
209
+
event: self.event.into_static(),
210
+
external_id: self.external_id.into_static(),
211
+
mod_tool: self.mod_tool.into_static(),
212
+
subject: self.subject.into_static(),
213
+
subject_blob_cids: self.subject_blob_cids.into_static(),
214
+
extra_data: self.extra_data.into_static(),
215
+
}
216
+
}
217
+
}
218
+
110
219
#[jacquard_derive::lexicon]
111
220
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
112
221
#[serde(rename_all = "camelCase")]
···
114
223
#[serde(flatten)]
115
224
#[serde(borrow)]
116
225
pub value: crate::tools_ozone::moderation::ModEventView<'a>,
226
+
}
227
+
228
+
impl jacquard_common::IntoStatic for EmitEventOutput<'_> {
229
+
type Output = EmitEventOutput<'static>;
230
+
fn into_static(self) -> Self::Output {
231
+
EmitEventOutput {
232
+
value: self.value.into_static(),
233
+
extra_data: self.extra_data.into_static(),
234
+
}
235
+
}
117
236
}
118
237
119
238
#[jacquard_derive::open_union]
···
155
274
Ok(())
156
275
}
157
276
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
277
+
}
278
+
}
279
+
}
280
+
281
+
impl jacquard_common::IntoStatic for EmitEventError<'_> {
282
+
type Output = EmitEventError<'static>;
283
+
fn into_static(self) -> Self::Output {
284
+
match self {
285
+
EmitEventError::SubjectHasAction(v) => {
286
+
EmitEventError::SubjectHasAction(v.into_static())
287
+
}
288
+
EmitEventError::DuplicateExternalId(v) => {
289
+
EmitEventError::DuplicateExternalId(v.into_static())
290
+
}
291
+
EmitEventError::Unknown(v) => EmitEventError::Unknown(v.into_static()),
158
292
}
159
293
}
160
294
}
+56
crates/jacquard-api/src/tools_ozone/moderation/get_account_timeline.rs
+56
crates/jacquard-api/src/tools_ozone/moderation/get_account_timeline.rs
···
12
12
pub did: jacquard_common::types::string::Did<'a>,
13
13
}
14
14
15
+
impl jacquard_common::IntoStatic for GetAccountTimeline<'_> {
16
+
type Output = GetAccountTimeline<'static>;
17
+
fn into_static(self) -> Self::Output {
18
+
GetAccountTimeline {
19
+
did: self.did.into_static(),
20
+
}
21
+
}
22
+
}
23
+
15
24
#[jacquard_derive::lexicon]
16
25
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
26
#[serde(rename_all = "camelCase")]
18
27
pub struct GetAccountTimelineOutput<'a> {
19
28
#[serde(borrow)]
20
29
pub timeline: Vec<jacquard_common::types::value::Data<'a>>,
30
+
}
31
+
32
+
impl jacquard_common::IntoStatic for GetAccountTimelineOutput<'_> {
33
+
type Output = GetAccountTimelineOutput<'static>;
34
+
fn into_static(self) -> Self::Output {
35
+
GetAccountTimelineOutput {
36
+
timeline: self.timeline.into_static(),
37
+
extra_data: self.extra_data.into_static(),
38
+
}
39
+
}
21
40
}
22
41
23
42
#[jacquard_derive::open_union]
···
53
72
}
54
73
}
55
74
75
+
impl jacquard_common::IntoStatic for GetAccountTimelineError<'_> {
76
+
type Output = GetAccountTimelineError<'static>;
77
+
fn into_static(self) -> Self::Output {
78
+
match self {
79
+
GetAccountTimelineError::RepoNotFound(v) => {
80
+
GetAccountTimelineError::RepoNotFound(v.into_static())
81
+
}
82
+
GetAccountTimelineError::Unknown(v) => {
83
+
GetAccountTimelineError::Unknown(v.into_static())
84
+
}
85
+
}
86
+
}
87
+
}
88
+
56
89
impl jacquard_common::types::xrpc::XrpcRequest for GetAccountTimeline<'_> {
57
90
const NSID: &'static str = "tools.ozone.moderation.getAccountTimeline";
58
91
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
···
73
106
>,
74
107
}
75
108
109
+
impl jacquard_common::IntoStatic for TimelineItem<'_> {
110
+
type Output = TimelineItem<'static>;
111
+
fn into_static(self) -> Self::Output {
112
+
TimelineItem {
113
+
day: self.day.into_static(),
114
+
summary: self.summary.into_static(),
115
+
extra_data: self.extra_data.into_static(),
116
+
}
117
+
}
118
+
}
119
+
76
120
#[jacquard_derive::lexicon]
77
121
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
78
122
#[serde(rename_all = "camelCase")]
···
82
126
pub event_subject_type: jacquard_common::CowStr<'a>,
83
127
#[serde(borrow)]
84
128
pub event_type: jacquard_common::CowStr<'a>,
129
+
}
130
+
131
+
impl jacquard_common::IntoStatic for TimelineItemSummary<'_> {
132
+
type Output = TimelineItemSummary<'static>;
133
+
fn into_static(self) -> Self::Output {
134
+
TimelineItemSummary {
135
+
count: self.count.into_static(),
136
+
event_subject_type: self.event_subject_type.into_static(),
137
+
event_type: self.event_type.into_static(),
138
+
extra_data: self.extra_data.into_static(),
139
+
}
140
+
}
85
141
}
+18
-1
crates/jacquard-api/src/tools_ozone/moderation/get_event.rs
+18
-1
crates/jacquard-api/src/tools_ozone/moderation/get_event.rs
···
11
11
pub id: i64,
12
12
}
13
13
14
+
impl jacquard_common::IntoStatic for GetEvent {
15
+
type Output = GetEvent;
16
+
fn into_static(self) -> Self::Output {
17
+
self
18
+
}
19
+
}
20
+
14
21
#[jacquard_derive::lexicon]
15
22
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
16
23
#[serde(rename_all = "camelCase")]
···
20
27
pub value: crate::tools_ozone::moderation::ModEventViewDetail<'a>,
21
28
}
22
29
30
+
impl jacquard_common::IntoStatic for GetEventOutput<'_> {
31
+
type Output = GetEventOutput<'static>;
32
+
fn into_static(self) -> Self::Output {
33
+
GetEventOutput {
34
+
value: self.value.into_static(),
35
+
extra_data: self.extra_data.into_static(),
36
+
}
37
+
}
38
+
}
39
+
23
40
impl jacquard_common::types::xrpc::XrpcRequest for GetEvent {
24
41
const NSID: &'static str = "tools.ozone.moderation.getEvent";
25
42
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
26
43
const OUTPUT_ENCODING: &'static str = "application/json";
27
44
type Output<'de> = GetEventOutput<'de>;
28
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
45
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
29
46
}
+32
crates/jacquard-api/src/tools_ozone/moderation/get_record.rs
+32
crates/jacquard-api/src/tools_ozone/moderation/get_record.rs
···
15
15
pub uri: jacquard_common::types::string::AtUri<'a>,
16
16
}
17
17
18
+
impl jacquard_common::IntoStatic for GetRecord<'_> {
19
+
type Output = GetRecord<'static>;
20
+
fn into_static(self) -> Self::Output {
21
+
GetRecord {
22
+
cid: self.cid.into_static(),
23
+
uri: self.uri.into_static(),
24
+
}
25
+
}
26
+
}
27
+
18
28
#[jacquard_derive::lexicon]
19
29
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
20
30
#[serde(rename_all = "camelCase")]
···
24
34
pub value: crate::tools_ozone::moderation::RecordViewDetail<'a>,
25
35
}
26
36
37
+
impl jacquard_common::IntoStatic for GetRecordOutput<'_> {
38
+
type Output = GetRecordOutput<'static>;
39
+
fn into_static(self) -> Self::Output {
40
+
GetRecordOutput {
41
+
value: self.value.into_static(),
42
+
extra_data: self.extra_data.into_static(),
43
+
}
44
+
}
45
+
}
46
+
27
47
#[jacquard_derive::open_union]
28
48
#[derive(
29
49
serde::Serialize,
···
53
73
Ok(())
54
74
}
55
75
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
76
+
}
77
+
}
78
+
}
79
+
80
+
impl jacquard_common::IntoStatic for GetRecordError<'_> {
81
+
type Output = GetRecordError<'static>;
82
+
fn into_static(self) -> Self::Output {
83
+
match self {
84
+
GetRecordError::RecordNotFound(v) => {
85
+
GetRecordError::RecordNotFound(v.into_static())
86
+
}
87
+
GetRecordError::Unknown(v) => GetRecordError::Unknown(v.into_static()),
56
88
}
57
89
}
58
90
}
+20
-1
crates/jacquard-api/src/tools_ozone/moderation/get_records.rs
+20
-1
crates/jacquard-api/src/tools_ozone/moderation/get_records.rs
···
12
12
pub uris: Vec<jacquard_common::types::string::AtUri<'a>>,
13
13
}
14
14
15
+
impl jacquard_common::IntoStatic for GetRecords<'_> {
16
+
type Output = GetRecords<'static>;
17
+
fn into_static(self) -> Self::Output {
18
+
GetRecords {
19
+
uris: self.uris.into_static(),
20
+
}
21
+
}
22
+
}
23
+
15
24
#[jacquard_derive::lexicon]
16
25
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
26
#[serde(rename_all = "camelCase")]
···
20
29
pub records: Vec<jacquard_common::types::value::Data<'a>>,
21
30
}
22
31
32
+
impl jacquard_common::IntoStatic for GetRecordsOutput<'_> {
33
+
type Output = GetRecordsOutput<'static>;
34
+
fn into_static(self) -> Self::Output {
35
+
GetRecordsOutput {
36
+
records: self.records.into_static(),
37
+
extra_data: self.extra_data.into_static(),
38
+
}
39
+
}
40
+
}
41
+
23
42
impl jacquard_common::types::xrpc::XrpcRequest for GetRecords<'_> {
24
43
const NSID: &'static str = "tools.ozone.moderation.getRecords";
25
44
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
26
45
const OUTPUT_ENCODING: &'static str = "application/json";
27
46
type Output<'de> = GetRecordsOutput<'de>;
28
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
47
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
29
48
}
+29
crates/jacquard-api/src/tools_ozone/moderation/get_repo.rs
+29
crates/jacquard-api/src/tools_ozone/moderation/get_repo.rs
···
12
12
pub did: jacquard_common::types::string::Did<'a>,
13
13
}
14
14
15
+
impl jacquard_common::IntoStatic for GetRepo<'_> {
16
+
type Output = GetRepo<'static>;
17
+
fn into_static(self) -> Self::Output {
18
+
GetRepo {
19
+
did: self.did.into_static(),
20
+
}
21
+
}
22
+
}
23
+
15
24
#[jacquard_derive::lexicon]
16
25
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
26
#[serde(rename_all = "camelCase")]
···
21
30
pub value: crate::tools_ozone::moderation::RepoViewDetail<'a>,
22
31
}
23
32
33
+
impl jacquard_common::IntoStatic for GetRepoOutput<'_> {
34
+
type Output = GetRepoOutput<'static>;
35
+
fn into_static(self) -> Self::Output {
36
+
GetRepoOutput {
37
+
value: self.value.into_static(),
38
+
extra_data: self.extra_data.into_static(),
39
+
}
40
+
}
41
+
}
42
+
24
43
#[jacquard_derive::open_union]
25
44
#[derive(
26
45
serde::Serialize,
···
50
69
Ok(())
51
70
}
52
71
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
72
+
}
73
+
}
74
+
}
75
+
76
+
impl jacquard_common::IntoStatic for GetRepoError<'_> {
77
+
type Output = GetRepoError<'static>;
78
+
fn into_static(self) -> Self::Output {
79
+
match self {
80
+
GetRepoError::RepoNotFound(v) => GetRepoError::RepoNotFound(v.into_static()),
81
+
GetRepoError::Unknown(v) => GetRepoError::Unknown(v.into_static()),
53
82
}
54
83
}
55
84
}
+20
-1
crates/jacquard-api/src/tools_ozone/moderation/get_reporter_stats.rs
+20
-1
crates/jacquard-api/src/tools_ozone/moderation/get_reporter_stats.rs
···
12
12
pub dids: Vec<jacquard_common::types::string::Did<'a>>,
13
13
}
14
14
15
+
impl jacquard_common::IntoStatic for GetReporterStats<'_> {
16
+
type Output = GetReporterStats<'static>;
17
+
fn into_static(self) -> Self::Output {
18
+
GetReporterStats {
19
+
dids: self.dids.into_static(),
20
+
}
21
+
}
22
+
}
23
+
15
24
#[jacquard_derive::lexicon]
16
25
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
26
#[serde(rename_all = "camelCase")]
···
20
29
pub stats: Vec<crate::tools_ozone::moderation::ReporterStats<'a>>,
21
30
}
22
31
32
+
impl jacquard_common::IntoStatic for GetReporterStatsOutput<'_> {
33
+
type Output = GetReporterStatsOutput<'static>;
34
+
fn into_static(self) -> Self::Output {
35
+
GetReporterStatsOutput {
36
+
stats: self.stats.into_static(),
37
+
extra_data: self.extra_data.into_static(),
38
+
}
39
+
}
40
+
}
41
+
23
42
impl jacquard_common::types::xrpc::XrpcRequest for GetReporterStats<'_> {
24
43
const NSID: &'static str = "tools.ozone.moderation.getReporterStats";
25
44
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
26
45
const OUTPUT_ENCODING: &'static str = "application/json";
27
46
type Output<'de> = GetReporterStatsOutput<'de>;
28
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
47
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
29
48
}
+20
-1
crates/jacquard-api/src/tools_ozone/moderation/get_repos.rs
+20
-1
crates/jacquard-api/src/tools_ozone/moderation/get_repos.rs
···
12
12
pub dids: Vec<jacquard_common::types::string::Did<'a>>,
13
13
}
14
14
15
+
impl jacquard_common::IntoStatic for GetRepos<'_> {
16
+
type Output = GetRepos<'static>;
17
+
fn into_static(self) -> Self::Output {
18
+
GetRepos {
19
+
dids: self.dids.into_static(),
20
+
}
21
+
}
22
+
}
23
+
15
24
#[jacquard_derive::lexicon]
16
25
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
26
#[serde(rename_all = "camelCase")]
···
20
29
pub repos: Vec<jacquard_common::types::value::Data<'a>>,
21
30
}
22
31
32
+
impl jacquard_common::IntoStatic for GetReposOutput<'_> {
33
+
type Output = GetReposOutput<'static>;
34
+
fn into_static(self) -> Self::Output {
35
+
GetReposOutput {
36
+
repos: self.repos.into_static(),
37
+
extra_data: self.extra_data.into_static(),
38
+
}
39
+
}
40
+
}
41
+
23
42
impl jacquard_common::types::xrpc::XrpcRequest for GetRepos<'_> {
24
43
const NSID: &'static str = "tools.ozone.moderation.getRepos";
25
44
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
26
45
const OUTPUT_ENCODING: &'static str = "application/json";
27
46
type Output<'de> = GetReposOutput<'de>;
28
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
47
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
29
48
}
+20
-1
crates/jacquard-api/src/tools_ozone/moderation/get_subjects.rs
+20
-1
crates/jacquard-api/src/tools_ozone/moderation/get_subjects.rs
···
12
12
pub subjects: Vec<jacquard_common::CowStr<'a>>,
13
13
}
14
14
15
+
impl jacquard_common::IntoStatic for GetSubjects<'_> {
16
+
type Output = GetSubjects<'static>;
17
+
fn into_static(self) -> Self::Output {
18
+
GetSubjects {
19
+
subjects: self.subjects.into_static(),
20
+
}
21
+
}
22
+
}
23
+
15
24
#[jacquard_derive::lexicon]
16
25
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
26
#[serde(rename_all = "camelCase")]
···
20
29
pub subjects: Vec<crate::tools_ozone::moderation::SubjectView<'a>>,
21
30
}
22
31
32
+
impl jacquard_common::IntoStatic for GetSubjectsOutput<'_> {
33
+
type Output = GetSubjectsOutput<'static>;
34
+
fn into_static(self) -> Self::Output {
35
+
GetSubjectsOutput {
36
+
subjects: self.subjects.into_static(),
37
+
extra_data: self.extra_data.into_static(),
38
+
}
39
+
}
40
+
}
41
+
23
42
impl jacquard_common::types::xrpc::XrpcRequest for GetSubjects<'_> {
24
43
const NSID: &'static str = "tools.ozone.moderation.getSubjects";
25
44
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
26
45
const OUTPUT_ENCODING: &'static str = "application/json";
27
46
type Output<'de> = GetSubjectsOutput<'de>;
28
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
47
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
29
48
}
+42
-27
crates/jacquard-api/src/tools_ozone/moderation/query_events.rs
+42
-27
crates/jacquard-api/src/tools_ozone/moderation/query_events.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct QueryEvents<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
38
38
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
39
39
#[serde(skip_serializing_if = "std::option::Option::is_none")]
40
40
pub has_comment: std::option::Option<bool>,
41
+
///(default: false)
41
42
#[serde(skip_serializing_if = "std::option::Option::is_none")]
42
43
pub include_all_user_records: std::option::Option<bool>,
44
+
///(default: 50, min: 1, max: 100)
43
45
#[serde(skip_serializing_if = "std::option::Option::is_none")]
44
46
pub limit: std::option::Option<i64>,
45
47
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
57
59
#[serde(skip_serializing_if = "std::option::Option::is_none")]
58
60
#[serde(borrow)]
59
61
pub report_types: std::option::Option<Vec<jacquard_common::CowStr<'a>>>,
62
+
///(default: "desc")
60
63
#[serde(skip_serializing_if = "std::option::Option::is_none")]
61
64
#[serde(borrow)]
62
65
pub sort_direction: std::option::Option<jacquard_common::CowStr<'a>>,
···
71
74
pub types: std::option::Option<Vec<jacquard_common::CowStr<'a>>>,
72
75
}
73
76
74
-
impl Default for QueryEvents<'_> {
75
-
fn default() -> Self {
76
-
Self {
77
-
added_labels: Default::default(),
78
-
added_tags: Default::default(),
79
-
age_assurance_state: Default::default(),
80
-
batch_id: Default::default(),
81
-
collections: Default::default(),
82
-
comment: Default::default(),
83
-
created_after: Default::default(),
84
-
created_before: Default::default(),
85
-
created_by: Default::default(),
86
-
cursor: Default::default(),
87
-
has_comment: Default::default(),
88
-
include_all_user_records: Some(false),
89
-
limit: Some(50i64),
90
-
mod_tool: Default::default(),
91
-
policies: Default::default(),
92
-
removed_labels: Default::default(),
93
-
removed_tags: Default::default(),
94
-
report_types: Default::default(),
95
-
sort_direction: Some(jacquard_common::CowStr::from("desc")),
96
-
subject: Default::default(),
97
-
subject_type: Default::default(),
98
-
types: Default::default(),
77
+
impl jacquard_common::IntoStatic for QueryEvents<'_> {
78
+
type Output = QueryEvents<'static>;
79
+
fn into_static(self) -> Self::Output {
80
+
QueryEvents {
81
+
added_labels: self.added_labels.into_static(),
82
+
added_tags: self.added_tags.into_static(),
83
+
age_assurance_state: self.age_assurance_state.into_static(),
84
+
batch_id: self.batch_id.into_static(),
85
+
collections: self.collections.into_static(),
86
+
comment: self.comment.into_static(),
87
+
created_after: self.created_after.into_static(),
88
+
created_before: self.created_before.into_static(),
89
+
created_by: self.created_by.into_static(),
90
+
cursor: self.cursor.into_static(),
91
+
has_comment: self.has_comment.into_static(),
92
+
include_all_user_records: self.include_all_user_records.into_static(),
93
+
limit: self.limit.into_static(),
94
+
mod_tool: self.mod_tool.into_static(),
95
+
policies: self.policies.into_static(),
96
+
removed_labels: self.removed_labels.into_static(),
97
+
removed_tags: self.removed_tags.into_static(),
98
+
report_types: self.report_types.into_static(),
99
+
sort_direction: self.sort_direction.into_static(),
100
+
subject: self.subject.into_static(),
101
+
subject_type: self.subject_type.into_static(),
102
+
types: self.types.into_static(),
99
103
}
100
104
}
101
105
}
···
111
115
pub events: Vec<crate::tools_ozone::moderation::ModEventView<'a>>,
112
116
}
113
117
118
+
impl jacquard_common::IntoStatic for QueryEventsOutput<'_> {
119
+
type Output = QueryEventsOutput<'static>;
120
+
fn into_static(self) -> Self::Output {
121
+
QueryEventsOutput {
122
+
cursor: self.cursor.into_static(),
123
+
events: self.events.into_static(),
124
+
extra_data: self.extra_data.into_static(),
125
+
}
126
+
}
127
+
}
128
+
114
129
impl jacquard_common::types::xrpc::XrpcRequest for QueryEvents<'_> {
115
130
const NSID: &'static str = "tools.ozone.moderation.queryEvents";
116
131
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
117
132
const OUTPUT_ENCODING: &'static str = "application/json";
118
133
type Output<'de> = QueryEventsOutput<'de>;
119
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
134
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
120
135
}
+56
-40
crates/jacquard-api/src/tools_ozone/moderation/query_statuses.rs
+56
-40
crates/jacquard-api/src/tools_ozone/moderation/query_statuses.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct QueryStatuses<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
56
56
#[serde(skip_serializing_if = "std::option::Option::is_none")]
57
57
#[serde(borrow)]
58
58
pub last_reviewed_by: std::option::Option<jacquard_common::types::string::Did<'a>>,
59
+
///(default: 50, min: 1, max: 100)
59
60
#[serde(skip_serializing_if = "std::option::Option::is_none")]
60
61
pub limit: std::option::Option<i64>,
61
62
#[serde(skip_serializing_if = "std::option::Option::is_none")]
62
63
pub min_account_suspend_count: std::option::Option<i64>,
64
+
///(min: 0, max: 100)
63
65
#[serde(skip_serializing_if = "std::option::Option::is_none")]
64
66
pub min_priority_score: std::option::Option<i64>,
65
67
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
86
88
pub reviewed_after: std::option::Option<jacquard_common::types::string::Datetime>,
87
89
#[serde(skip_serializing_if = "std::option::Option::is_none")]
88
90
pub reviewed_before: std::option::Option<jacquard_common::types::string::Datetime>,
91
+
///(default: "desc")
89
92
#[serde(skip_serializing_if = "std::option::Option::is_none")]
90
93
#[serde(borrow)]
91
94
pub sort_direction: std::option::Option<jacquard_common::CowStr<'a>>,
95
+
///(default: "lastReportedAt")
92
96
#[serde(skip_serializing_if = "std::option::Option::is_none")]
93
97
#[serde(borrow)]
94
98
pub sort_field: std::option::Option<jacquard_common::CowStr<'a>>,
···
105
109
pub takendown: std::option::Option<bool>,
106
110
}
107
111
108
-
impl Default for QueryStatuses<'_> {
109
-
fn default() -> Self {
110
-
Self {
111
-
age_assurance_state: Default::default(),
112
-
appealed: Default::default(),
113
-
collections: Default::default(),
114
-
comment: Default::default(),
115
-
cursor: Default::default(),
116
-
exclude_tags: Default::default(),
117
-
hosting_deleted_after: Default::default(),
118
-
hosting_deleted_before: Default::default(),
119
-
hosting_statuses: Default::default(),
120
-
hosting_updated_after: Default::default(),
121
-
hosting_updated_before: Default::default(),
122
-
ignore_subjects: Default::default(),
123
-
include_all_user_records: Default::default(),
124
-
include_muted: Default::default(),
125
-
last_reviewed_by: Default::default(),
126
-
limit: Some(50i64),
127
-
min_account_suspend_count: Default::default(),
128
-
min_priority_score: Default::default(),
129
-
min_reported_records_count: Default::default(),
130
-
min_takendown_records_count: Default::default(),
131
-
only_muted: Default::default(),
132
-
queue_count: Default::default(),
133
-
queue_index: Default::default(),
134
-
queue_seed: Default::default(),
135
-
reported_after: Default::default(),
136
-
reported_before: Default::default(),
137
-
review_state: Default::default(),
138
-
reviewed_after: Default::default(),
139
-
reviewed_before: Default::default(),
140
-
sort_direction: Some(jacquard_common::CowStr::from("desc")),
141
-
sort_field: Some(jacquard_common::CowStr::from("lastReportedAt")),
142
-
subject: Default::default(),
143
-
subject_type: Default::default(),
144
-
tags: Default::default(),
145
-
takendown: Default::default(),
112
+
impl jacquard_common::IntoStatic for QueryStatuses<'_> {
113
+
type Output = QueryStatuses<'static>;
114
+
fn into_static(self) -> Self::Output {
115
+
QueryStatuses {
116
+
age_assurance_state: self.age_assurance_state.into_static(),
117
+
appealed: self.appealed.into_static(),
118
+
collections: self.collections.into_static(),
119
+
comment: self.comment.into_static(),
120
+
cursor: self.cursor.into_static(),
121
+
exclude_tags: self.exclude_tags.into_static(),
122
+
hosting_deleted_after: self.hosting_deleted_after.into_static(),
123
+
hosting_deleted_before: self.hosting_deleted_before.into_static(),
124
+
hosting_statuses: self.hosting_statuses.into_static(),
125
+
hosting_updated_after: self.hosting_updated_after.into_static(),
126
+
hosting_updated_before: self.hosting_updated_before.into_static(),
127
+
ignore_subjects: self.ignore_subjects.into_static(),
128
+
include_all_user_records: self.include_all_user_records.into_static(),
129
+
include_muted: self.include_muted.into_static(),
130
+
last_reviewed_by: self.last_reviewed_by.into_static(),
131
+
limit: self.limit.into_static(),
132
+
min_account_suspend_count: self.min_account_suspend_count.into_static(),
133
+
min_priority_score: self.min_priority_score.into_static(),
134
+
min_reported_records_count: self.min_reported_records_count.into_static(),
135
+
min_takendown_records_count: self.min_takendown_records_count.into_static(),
136
+
only_muted: self.only_muted.into_static(),
137
+
queue_count: self.queue_count.into_static(),
138
+
queue_index: self.queue_index.into_static(),
139
+
queue_seed: self.queue_seed.into_static(),
140
+
reported_after: self.reported_after.into_static(),
141
+
reported_before: self.reported_before.into_static(),
142
+
review_state: self.review_state.into_static(),
143
+
reviewed_after: self.reviewed_after.into_static(),
144
+
reviewed_before: self.reviewed_before.into_static(),
145
+
sort_direction: self.sort_direction.into_static(),
146
+
sort_field: self.sort_field.into_static(),
147
+
subject: self.subject.into_static(),
148
+
subject_type: self.subject_type.into_static(),
149
+
tags: self.tags.into_static(),
150
+
takendown: self.takendown.into_static(),
146
151
}
147
152
}
148
153
}
···
158
163
pub subject_statuses: Vec<crate::tools_ozone::moderation::SubjectStatusView<'a>>,
159
164
}
160
165
166
+
impl jacquard_common::IntoStatic for QueryStatusesOutput<'_> {
167
+
type Output = QueryStatusesOutput<'static>;
168
+
fn into_static(self) -> Self::Output {
169
+
QueryStatusesOutput {
170
+
cursor: self.cursor.into_static(),
171
+
subject_statuses: self.subject_statuses.into_static(),
172
+
extra_data: self.extra_data.into_static(),
173
+
}
174
+
}
175
+
}
176
+
161
177
impl jacquard_common::types::xrpc::XrpcRequest for QueryStatuses<'_> {
162
178
const NSID: &'static str = "tools.ozone.moderation.queryStatuses";
163
179
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
164
180
const OUTPUT_ENCODING: &'static str = "application/json";
165
181
type Output<'de> = QueryStatusesOutput<'de>;
166
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
182
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
167
183
}
+22
-9
crates/jacquard-api/src/tools_ozone/moderation/search_repos.rs
+22
-9
crates/jacquard-api/src/tools_ozone/moderation/search_repos.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct SearchRepos<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
12
#[serde(borrow)]
13
13
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
14
+
///(default: 50, min: 1, max: 100)
14
15
#[serde(skip_serializing_if = "std::option::Option::is_none")]
15
16
pub limit: std::option::Option<i64>,
16
17
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
21
22
pub term: std::option::Option<jacquard_common::CowStr<'a>>,
22
23
}
23
24
24
-
impl Default for SearchRepos<'_> {
25
-
fn default() -> Self {
26
-
Self {
27
-
cursor: Default::default(),
28
-
limit: Some(50i64),
29
-
q: Default::default(),
30
-
term: Default::default(),
25
+
impl jacquard_common::IntoStatic for SearchRepos<'_> {
26
+
type Output = SearchRepos<'static>;
27
+
fn into_static(self) -> Self::Output {
28
+
SearchRepos {
29
+
cursor: self.cursor.into_static(),
30
+
limit: self.limit.into_static(),
31
+
q: self.q.into_static(),
32
+
term: self.term.into_static(),
31
33
}
32
34
}
33
35
}
···
43
45
pub repos: Vec<crate::tools_ozone::moderation::RepoView<'a>>,
44
46
}
45
47
48
+
impl jacquard_common::IntoStatic for SearchReposOutput<'_> {
49
+
type Output = SearchReposOutput<'static>;
50
+
fn into_static(self) -> Self::Output {
51
+
SearchReposOutput {
52
+
cursor: self.cursor.into_static(),
53
+
repos: self.repos.into_static(),
54
+
extra_data: self.extra_data.into_static(),
55
+
}
56
+
}
57
+
}
58
+
46
59
impl jacquard_common::types::xrpc::XrpcRequest for SearchRepos<'_> {
47
60
const NSID: &'static str = "tools.ozone.moderation.searchRepos";
48
61
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
49
62
const OUTPUT_ENCODING: &'static str = "application/json";
50
63
type Output<'de> = SearchReposOutput<'de>;
51
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
64
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
52
65
}
+144
crates/jacquard-api/src/tools_ozone/report.rs
+144
crates/jacquard-api/src/tools_ozone/report.rs
···
510
510
let s = <&'de str>::deserialize(deserializer)?;
511
511
Ok(Self::from(s))
512
512
}
513
+
}
514
+
515
+
impl jacquard_common::IntoStatic for ReasonType<'_> {
516
+
type Output = ReasonType<'static>;
517
+
fn into_static(self) -> Self::Output {
518
+
match self {
519
+
ReasonType::ToolsOzoneReportDefsReasonAppeal => {
520
+
ReasonType::ToolsOzoneReportDefsReasonAppeal
521
+
}
522
+
ReasonType::ToolsOzoneReportDefsReasonViolenceAnimalWelfare => {
523
+
ReasonType::ToolsOzoneReportDefsReasonViolenceAnimalWelfare
524
+
}
525
+
ReasonType::ToolsOzoneReportDefsReasonViolenceThreats => {
526
+
ReasonType::ToolsOzoneReportDefsReasonViolenceThreats
527
+
}
528
+
ReasonType::ToolsOzoneReportDefsReasonViolenceGraphicContent => {
529
+
ReasonType::ToolsOzoneReportDefsReasonViolenceGraphicContent
530
+
}
531
+
ReasonType::ToolsOzoneReportDefsReasonViolenceSelfHarm => {
532
+
ReasonType::ToolsOzoneReportDefsReasonViolenceSelfHarm
533
+
}
534
+
ReasonType::ToolsOzoneReportDefsReasonViolenceGlorification => {
535
+
ReasonType::ToolsOzoneReportDefsReasonViolenceGlorification
536
+
}
537
+
ReasonType::ToolsOzoneReportDefsReasonViolenceExtremistContent => {
538
+
ReasonType::ToolsOzoneReportDefsReasonViolenceExtremistContent
539
+
}
540
+
ReasonType::ToolsOzoneReportDefsReasonViolenceTrafficking => {
541
+
ReasonType::ToolsOzoneReportDefsReasonViolenceTrafficking
542
+
}
543
+
ReasonType::ToolsOzoneReportDefsReasonViolenceOther => {
544
+
ReasonType::ToolsOzoneReportDefsReasonViolenceOther
545
+
}
546
+
ReasonType::ToolsOzoneReportDefsReasonSexualAbuseContent => {
547
+
ReasonType::ToolsOzoneReportDefsReasonSexualAbuseContent
548
+
}
549
+
ReasonType::ToolsOzoneReportDefsReasonSexualNcii => {
550
+
ReasonType::ToolsOzoneReportDefsReasonSexualNcii
551
+
}
552
+
ReasonType::ToolsOzoneReportDefsReasonSexualSextortion => {
553
+
ReasonType::ToolsOzoneReportDefsReasonSexualSextortion
554
+
}
555
+
ReasonType::ToolsOzoneReportDefsReasonSexualDeepfake => {
556
+
ReasonType::ToolsOzoneReportDefsReasonSexualDeepfake
557
+
}
558
+
ReasonType::ToolsOzoneReportDefsReasonSexualAnimal => {
559
+
ReasonType::ToolsOzoneReportDefsReasonSexualAnimal
560
+
}
561
+
ReasonType::ToolsOzoneReportDefsReasonSexualUnlabeled => {
562
+
ReasonType::ToolsOzoneReportDefsReasonSexualUnlabeled
563
+
}
564
+
ReasonType::ToolsOzoneReportDefsReasonSexualOther => {
565
+
ReasonType::ToolsOzoneReportDefsReasonSexualOther
566
+
}
567
+
ReasonType::ToolsOzoneReportDefsReasonChildSafetyCsam => {
568
+
ReasonType::ToolsOzoneReportDefsReasonChildSafetyCsam
569
+
}
570
+
ReasonType::ToolsOzoneReportDefsReasonChildSafetyGroom => {
571
+
ReasonType::ToolsOzoneReportDefsReasonChildSafetyGroom
572
+
}
573
+
ReasonType::ToolsOzoneReportDefsReasonChildSafetyMinorPrivacy => {
574
+
ReasonType::ToolsOzoneReportDefsReasonChildSafetyMinorPrivacy
575
+
}
576
+
ReasonType::ToolsOzoneReportDefsReasonChildSafetyEndangerment => {
577
+
ReasonType::ToolsOzoneReportDefsReasonChildSafetyEndangerment
578
+
}
579
+
ReasonType::ToolsOzoneReportDefsReasonChildSafetyHarassment => {
580
+
ReasonType::ToolsOzoneReportDefsReasonChildSafetyHarassment
581
+
}
582
+
ReasonType::ToolsOzoneReportDefsReasonChildSafetyPromotion => {
583
+
ReasonType::ToolsOzoneReportDefsReasonChildSafetyPromotion
584
+
}
585
+
ReasonType::ToolsOzoneReportDefsReasonChildSafetyOther => {
586
+
ReasonType::ToolsOzoneReportDefsReasonChildSafetyOther
587
+
}
588
+
ReasonType::ToolsOzoneReportDefsReasonHarassmentTroll => {
589
+
ReasonType::ToolsOzoneReportDefsReasonHarassmentTroll
590
+
}
591
+
ReasonType::ToolsOzoneReportDefsReasonHarassmentTargeted => {
592
+
ReasonType::ToolsOzoneReportDefsReasonHarassmentTargeted
593
+
}
594
+
ReasonType::ToolsOzoneReportDefsReasonHarassmentHateSpeech => {
595
+
ReasonType::ToolsOzoneReportDefsReasonHarassmentHateSpeech
596
+
}
597
+
ReasonType::ToolsOzoneReportDefsReasonHarassmentDoxxing => {
598
+
ReasonType::ToolsOzoneReportDefsReasonHarassmentDoxxing
599
+
}
600
+
ReasonType::ToolsOzoneReportDefsReasonHarassmentOther => {
601
+
ReasonType::ToolsOzoneReportDefsReasonHarassmentOther
602
+
}
603
+
ReasonType::ToolsOzoneReportDefsReasonMisleadingBot => {
604
+
ReasonType::ToolsOzoneReportDefsReasonMisleadingBot
605
+
}
606
+
ReasonType::ToolsOzoneReportDefsReasonMisleadingImpersonation => {
607
+
ReasonType::ToolsOzoneReportDefsReasonMisleadingImpersonation
608
+
}
609
+
ReasonType::ToolsOzoneReportDefsReasonMisleadingSpam => {
610
+
ReasonType::ToolsOzoneReportDefsReasonMisleadingSpam
611
+
}
612
+
ReasonType::ToolsOzoneReportDefsReasonMisleadingScam => {
613
+
ReasonType::ToolsOzoneReportDefsReasonMisleadingScam
614
+
}
615
+
ReasonType::ToolsOzoneReportDefsReasonMisleadingSyntheticContent => {
616
+
ReasonType::ToolsOzoneReportDefsReasonMisleadingSyntheticContent
617
+
}
618
+
ReasonType::ToolsOzoneReportDefsReasonMisleadingMisinformation => {
619
+
ReasonType::ToolsOzoneReportDefsReasonMisleadingMisinformation
620
+
}
621
+
ReasonType::ToolsOzoneReportDefsReasonMisleadingOther => {
622
+
ReasonType::ToolsOzoneReportDefsReasonMisleadingOther
623
+
}
624
+
ReasonType::ToolsOzoneReportDefsReasonRuleSiteSecurity => {
625
+
ReasonType::ToolsOzoneReportDefsReasonRuleSiteSecurity
626
+
}
627
+
ReasonType::ToolsOzoneReportDefsReasonRuleStolenContent => {
628
+
ReasonType::ToolsOzoneReportDefsReasonRuleStolenContent
629
+
}
630
+
ReasonType::ToolsOzoneReportDefsReasonRuleProhibitedSales => {
631
+
ReasonType::ToolsOzoneReportDefsReasonRuleProhibitedSales
632
+
}
633
+
ReasonType::ToolsOzoneReportDefsReasonRuleBanEvasion => {
634
+
ReasonType::ToolsOzoneReportDefsReasonRuleBanEvasion
635
+
}
636
+
ReasonType::ToolsOzoneReportDefsReasonRuleOther => {
637
+
ReasonType::ToolsOzoneReportDefsReasonRuleOther
638
+
}
639
+
ReasonType::ToolsOzoneReportDefsReasonCivicElectoralProcess => {
640
+
ReasonType::ToolsOzoneReportDefsReasonCivicElectoralProcess
641
+
}
642
+
ReasonType::ToolsOzoneReportDefsReasonCivicDisclosure => {
643
+
ReasonType::ToolsOzoneReportDefsReasonCivicDisclosure
644
+
}
645
+
ReasonType::ToolsOzoneReportDefsReasonCivicInterference => {
646
+
ReasonType::ToolsOzoneReportDefsReasonCivicInterference
647
+
}
648
+
ReasonType::ToolsOzoneReportDefsReasonCivicMisinformation => {
649
+
ReasonType::ToolsOzoneReportDefsReasonCivicMisinformation
650
+
}
651
+
ReasonType::ToolsOzoneReportDefsReasonCivicImpersonation => {
652
+
ReasonType::ToolsOzoneReportDefsReasonCivicImpersonation
653
+
}
654
+
ReasonType::Other(v) => ReasonType::Other(v.into_static()),
655
+
}
656
+
}
513
657
}
+83
crates/jacquard-api/src/tools_ozone/safelink.rs
+83
crates/jacquard-api/src/tools_ozone/safelink.rs
···
80
80
}
81
81
}
82
82
83
+
impl jacquard_common::IntoStatic for ActionType<'_> {
84
+
type Output = ActionType<'static>;
85
+
fn into_static(self) -> Self::Output {
86
+
match self {
87
+
ActionType::Block => ActionType::Block,
88
+
ActionType::Warn => ActionType::Warn,
89
+
ActionType::Whitelist => ActionType::Whitelist,
90
+
ActionType::Other(v) => ActionType::Other(v.into_static()),
91
+
}
92
+
}
93
+
}
94
+
83
95
///An event for URL safety decisions
84
96
#[jacquard_derive::lexicon]
85
97
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
106
118
///The URL that this rule applies to
107
119
#[serde(borrow)]
108
120
pub url: jacquard_common::CowStr<'a>,
121
+
}
122
+
123
+
impl jacquard_common::IntoStatic for Event<'_> {
124
+
type Output = Event<'static>;
125
+
fn into_static(self) -> Self::Output {
126
+
Event {
127
+
action: self.action.into_static(),
128
+
comment: self.comment.into_static(),
129
+
created_at: self.created_at.into_static(),
130
+
created_by: self.created_by.into_static(),
131
+
event_type: self.event_type.into_static(),
132
+
id: self.id.into_static(),
133
+
pattern: self.pattern.into_static(),
134
+
reason: self.reason.into_static(),
135
+
url: self.url.into_static(),
136
+
extra_data: self.extra_data.into_static(),
137
+
}
138
+
}
109
139
}
110
140
111
141
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
···
174
204
{
175
205
let s = <&'de str>::deserialize(deserializer)?;
176
206
Ok(Self::from(s))
207
+
}
208
+
}
209
+
210
+
impl jacquard_common::IntoStatic for EventType<'_> {
211
+
type Output = EventType<'static>;
212
+
fn into_static(self) -> Self::Output {
213
+
match self {
214
+
EventType::AddRule => EventType::AddRule,
215
+
EventType::UpdateRule => EventType::UpdateRule,
216
+
EventType::RemoveRule => EventType::RemoveRule,
217
+
EventType::Other(v) => EventType::Other(v.into_static()),
218
+
}
177
219
}
178
220
}
179
221
···
242
284
}
243
285
}
244
286
287
+
impl jacquard_common::IntoStatic for PatternType<'_> {
288
+
type Output = PatternType<'static>;
289
+
fn into_static(self) -> Self::Output {
290
+
match self {
291
+
PatternType::Domain => PatternType::Domain,
292
+
PatternType::Url => PatternType::Url,
293
+
PatternType::Other(v) => PatternType::Other(v.into_static()),
294
+
}
295
+
}
296
+
}
297
+
245
298
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
246
299
pub enum ReasonType<'a> {
247
300
Csam,
···
315
368
}
316
369
}
317
370
371
+
impl jacquard_common::IntoStatic for ReasonType<'_> {
372
+
type Output = ReasonType<'static>;
373
+
fn into_static(self) -> Self::Output {
374
+
match self {
375
+
ReasonType::Csam => ReasonType::Csam,
376
+
ReasonType::Spam => ReasonType::Spam,
377
+
ReasonType::Phishing => ReasonType::Phishing,
378
+
ReasonType::None => ReasonType::None,
379
+
ReasonType::Other(v) => ReasonType::Other(v.into_static()),
380
+
}
381
+
}
382
+
}
383
+
318
384
///Input for creating a URL safety rule
319
385
#[jacquard_derive::lexicon]
320
386
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
···
340
406
///The URL or domain to apply the rule to
341
407
#[serde(borrow)]
342
408
pub url: jacquard_common::CowStr<'a>,
409
+
}
410
+
411
+
impl jacquard_common::IntoStatic for UrlRule<'_> {
412
+
type Output = UrlRule<'static>;
413
+
fn into_static(self) -> Self::Output {
414
+
UrlRule {
415
+
action: self.action.into_static(),
416
+
comment: self.comment.into_static(),
417
+
created_at: self.created_at.into_static(),
418
+
created_by: self.created_by.into_static(),
419
+
pattern: self.pattern.into_static(),
420
+
reason: self.reason.into_static(),
421
+
updated_at: self.updated_at.into_static(),
422
+
url: self.url.into_static(),
423
+
extra_data: self.extra_data.into_static(),
424
+
}
425
+
}
343
426
}
+38
crates/jacquard-api/src/tools_ozone/safelink/add_rule.rs
+38
crates/jacquard-api/src/tools_ozone/safelink/add_rule.rs
···
28
28
pub url: jacquard_common::CowStr<'a>,
29
29
}
30
30
31
+
impl jacquard_common::IntoStatic for AddRule<'_> {
32
+
type Output = AddRule<'static>;
33
+
fn into_static(self) -> Self::Output {
34
+
AddRule {
35
+
action: self.action.into_static(),
36
+
comment: self.comment.into_static(),
37
+
created_by: self.created_by.into_static(),
38
+
pattern: self.pattern.into_static(),
39
+
reason: self.reason.into_static(),
40
+
url: self.url.into_static(),
41
+
extra_data: self.extra_data.into_static(),
42
+
}
43
+
}
44
+
}
45
+
31
46
#[jacquard_derive::lexicon]
32
47
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
33
48
#[serde(rename_all = "camelCase")]
···
37
52
pub value: crate::tools_ozone::safelink::Event<'a>,
38
53
}
39
54
55
+
impl jacquard_common::IntoStatic for AddRuleOutput<'_> {
56
+
type Output = AddRuleOutput<'static>;
57
+
fn into_static(self) -> Self::Output {
58
+
AddRuleOutput {
59
+
value: self.value.into_static(),
60
+
extra_data: self.extra_data.into_static(),
61
+
}
62
+
}
63
+
}
64
+
40
65
#[jacquard_derive::open_union]
41
66
#[derive(
42
67
serde::Serialize,
···
77
102
Ok(())
78
103
}
79
104
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
105
+
}
106
+
}
107
+
}
108
+
109
+
impl jacquard_common::IntoStatic for AddRuleError<'_> {
110
+
type Output = AddRuleError<'static>;
111
+
fn into_static(self) -> Self::Output {
112
+
match self {
113
+
AddRuleError::InvalidUrl(v) => AddRuleError::InvalidUrl(v.into_static()),
114
+
AddRuleError::RuleAlreadyExists(v) => {
115
+
AddRuleError::RuleAlreadyExists(v.into_static())
116
+
}
117
+
AddRuleError::Unknown(v) => AddRuleError::Unknown(v.into_static()),
80
118
}
81
119
}
82
120
}
+26
-1
crates/jacquard-api/src/tools_ozone/safelink/query_events.rs
+26
-1
crates/jacquard-api/src/tools_ozone/safelink/query_events.rs
···
30
30
pub urls: std::option::Option<Vec<jacquard_common::CowStr<'a>>>,
31
31
}
32
32
33
+
impl jacquard_common::IntoStatic for QueryEvents<'_> {
34
+
type Output = QueryEvents<'static>;
35
+
fn into_static(self) -> Self::Output {
36
+
QueryEvents {
37
+
cursor: self.cursor.into_static(),
38
+
limit: self.limit.into_static(),
39
+
pattern_type: self.pattern_type.into_static(),
40
+
sort_direction: self.sort_direction.into_static(),
41
+
urls: self.urls.into_static(),
42
+
extra_data: self.extra_data.into_static(),
43
+
}
44
+
}
45
+
}
46
+
33
47
#[jacquard_derive::lexicon]
34
48
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
35
49
#[serde(rename_all = "camelCase")]
···
42
56
pub events: Vec<crate::tools_ozone::safelink::Event<'a>>,
43
57
}
44
58
59
+
impl jacquard_common::IntoStatic for QueryEventsOutput<'_> {
60
+
type Output = QueryEventsOutput<'static>;
61
+
fn into_static(self) -> Self::Output {
62
+
QueryEventsOutput {
63
+
cursor: self.cursor.into_static(),
64
+
events: self.events.into_static(),
65
+
extra_data: self.extra_data.into_static(),
66
+
}
67
+
}
68
+
}
69
+
45
70
impl jacquard_common::types::xrpc::XrpcRequest for QueryEvents<'_> {
46
71
const NSID: &'static str = "tools.ozone.safelink.queryEvents";
47
72
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
49
74
);
50
75
const OUTPUT_ENCODING: &'static str = "application/json";
51
76
type Output<'de> = QueryEventsOutput<'de>;
52
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
77
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
53
78
}
+29
-1
crates/jacquard-api/src/tools_ozone/safelink/query_rules.rs
+29
-1
crates/jacquard-api/src/tools_ozone/safelink/query_rules.rs
···
42
42
pub urls: std::option::Option<Vec<jacquard_common::CowStr<'a>>>,
43
43
}
44
44
45
+
impl jacquard_common::IntoStatic for QueryRules<'_> {
46
+
type Output = QueryRules<'static>;
47
+
fn into_static(self) -> Self::Output {
48
+
QueryRules {
49
+
actions: self.actions.into_static(),
50
+
created_by: self.created_by.into_static(),
51
+
cursor: self.cursor.into_static(),
52
+
limit: self.limit.into_static(),
53
+
pattern_type: self.pattern_type.into_static(),
54
+
reason: self.reason.into_static(),
55
+
sort_direction: self.sort_direction.into_static(),
56
+
urls: self.urls.into_static(),
57
+
extra_data: self.extra_data.into_static(),
58
+
}
59
+
}
60
+
}
61
+
45
62
#[jacquard_derive::lexicon]
46
63
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
47
64
#[serde(rename_all = "camelCase")]
···
54
71
pub rules: Vec<crate::tools_ozone::safelink::UrlRule<'a>>,
55
72
}
56
73
74
+
impl jacquard_common::IntoStatic for QueryRulesOutput<'_> {
75
+
type Output = QueryRulesOutput<'static>;
76
+
fn into_static(self) -> Self::Output {
77
+
QueryRulesOutput {
78
+
cursor: self.cursor.into_static(),
79
+
rules: self.rules.into_static(),
80
+
extra_data: self.extra_data.into_static(),
81
+
}
82
+
}
83
+
}
84
+
57
85
impl jacquard_common::types::xrpc::XrpcRequest for QueryRules<'_> {
58
86
const NSID: &'static str = "tools.ozone.safelink.queryRules";
59
87
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
61
89
);
62
90
const OUTPUT_ENCODING: &'static str = "application/json";
63
91
type Output<'de> = QueryRulesOutput<'de>;
64
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
92
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
65
93
}
+35
crates/jacquard-api/src/tools_ozone/safelink/remove_rule.rs
+35
crates/jacquard-api/src/tools_ozone/safelink/remove_rule.rs
···
24
24
pub url: jacquard_common::CowStr<'a>,
25
25
}
26
26
27
+
impl jacquard_common::IntoStatic for RemoveRule<'_> {
28
+
type Output = RemoveRule<'static>;
29
+
fn into_static(self) -> Self::Output {
30
+
RemoveRule {
31
+
comment: self.comment.into_static(),
32
+
created_by: self.created_by.into_static(),
33
+
pattern: self.pattern.into_static(),
34
+
url: self.url.into_static(),
35
+
extra_data: self.extra_data.into_static(),
36
+
}
37
+
}
38
+
}
39
+
27
40
#[jacquard_derive::lexicon]
28
41
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
29
42
#[serde(rename_all = "camelCase")]
···
33
46
pub value: crate::tools_ozone::safelink::Event<'a>,
34
47
}
35
48
49
+
impl jacquard_common::IntoStatic for RemoveRuleOutput<'_> {
50
+
type Output = RemoveRuleOutput<'static>;
51
+
fn into_static(self) -> Self::Output {
52
+
RemoveRuleOutput {
53
+
value: self.value.into_static(),
54
+
extra_data: self.extra_data.into_static(),
55
+
}
56
+
}
57
+
}
58
+
36
59
#[jacquard_derive::open_union]
37
60
#[derive(
38
61
serde::Serialize,
···
63
86
Ok(())
64
87
}
65
88
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
89
+
}
90
+
}
91
+
}
92
+
93
+
impl jacquard_common::IntoStatic for RemoveRuleError<'_> {
94
+
type Output = RemoveRuleError<'static>;
95
+
fn into_static(self) -> Self::Output {
96
+
match self {
97
+
RemoveRuleError::RuleNotFound(v) => {
98
+
RemoveRuleError::RuleNotFound(v.into_static())
99
+
}
100
+
RemoveRuleError::Unknown(v) => RemoveRuleError::Unknown(v.into_static()),
66
101
}
67
102
}
68
103
}
+37
crates/jacquard-api/src/tools_ozone/safelink/update_rule.rs
+37
crates/jacquard-api/src/tools_ozone/safelink/update_rule.rs
···
28
28
pub url: jacquard_common::CowStr<'a>,
29
29
}
30
30
31
+
impl jacquard_common::IntoStatic for UpdateRule<'_> {
32
+
type Output = UpdateRule<'static>;
33
+
fn into_static(self) -> Self::Output {
34
+
UpdateRule {
35
+
action: self.action.into_static(),
36
+
comment: self.comment.into_static(),
37
+
created_by: self.created_by.into_static(),
38
+
pattern: self.pattern.into_static(),
39
+
reason: self.reason.into_static(),
40
+
url: self.url.into_static(),
41
+
extra_data: self.extra_data.into_static(),
42
+
}
43
+
}
44
+
}
45
+
31
46
#[jacquard_derive::lexicon]
32
47
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
33
48
#[serde(rename_all = "camelCase")]
···
37
52
pub value: crate::tools_ozone::safelink::Event<'a>,
38
53
}
39
54
55
+
impl jacquard_common::IntoStatic for UpdateRuleOutput<'_> {
56
+
type Output = UpdateRuleOutput<'static>;
57
+
fn into_static(self) -> Self::Output {
58
+
UpdateRuleOutput {
59
+
value: self.value.into_static(),
60
+
extra_data: self.extra_data.into_static(),
61
+
}
62
+
}
63
+
}
64
+
40
65
#[jacquard_derive::open_union]
41
66
#[derive(
42
67
serde::Serialize,
···
67
92
Ok(())
68
93
}
69
94
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
95
+
}
96
+
}
97
+
}
98
+
99
+
impl jacquard_common::IntoStatic for UpdateRuleError<'_> {
100
+
type Output = UpdateRuleError<'static>;
101
+
fn into_static(self) -> Self::Output {
102
+
match self {
103
+
UpdateRuleError::RuleNotFound(v) => {
104
+
UpdateRuleError::RuleNotFound(v.into_static())
105
+
}
106
+
UpdateRuleError::Unknown(v) => UpdateRuleError::Unknown(v.into_static()),
70
107
}
71
108
}
72
109
}
+36
-1
crates/jacquard-api/src/tools_ozone/server/get_config.rs
+36
-1
crates/jacquard-api/src/tools_ozone/server/get_config.rs
···
30
30
pub viewer: std::option::Option<jacquard_common::types::value::Data<'a>>,
31
31
}
32
32
33
+
impl jacquard_common::IntoStatic for GetConfigOutput<'_> {
34
+
type Output = GetConfigOutput<'static>;
35
+
fn into_static(self) -> Self::Output {
36
+
GetConfigOutput {
37
+
appview: self.appview.into_static(),
38
+
blob_divert: self.blob_divert.into_static(),
39
+
chat: self.chat.into_static(),
40
+
pds: self.pds.into_static(),
41
+
verifier_did: self.verifier_did.into_static(),
42
+
viewer: self.viewer.into_static(),
43
+
extra_data: self.extra_data.into_static(),
44
+
}
45
+
}
46
+
}
47
+
33
48
/// XRPC request marker type
34
49
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]
35
50
pub struct GetConfig;
···
38
53
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
39
54
const OUTPUT_ENCODING: &'static str = "application/json";
40
55
type Output<'de> = GetConfigOutput<'de>;
41
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
56
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
42
57
}
43
58
44
59
#[jacquard_derive::lexicon]
···
50
65
pub url: std::option::Option<jacquard_common::types::string::Uri<'a>>,
51
66
}
52
67
68
+
impl jacquard_common::IntoStatic for ServiceConfig<'_> {
69
+
type Output = ServiceConfig<'static>;
70
+
fn into_static(self) -> Self::Output {
71
+
ServiceConfig {
72
+
url: self.url.into_static(),
73
+
extra_data: self.extra_data.into_static(),
74
+
}
75
+
}
76
+
}
77
+
53
78
#[jacquard_derive::lexicon]
54
79
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
55
80
#[serde(rename_all = "camelCase")]
···
57
82
#[serde(skip_serializing_if = "std::option::Option::is_none")]
58
83
#[serde(borrow)]
59
84
pub role: std::option::Option<jacquard_common::CowStr<'a>>,
85
+
}
86
+
87
+
impl jacquard_common::IntoStatic for ViewerConfig<'_> {
88
+
type Output = ViewerConfig<'static>;
89
+
fn into_static(self) -> Self::Output {
90
+
ViewerConfig {
91
+
role: self.role.into_static(),
92
+
extra_data: self.extra_data.into_static(),
93
+
}
94
+
}
60
95
}
+25
crates/jacquard-api/src/tools_ozone/set.rs
+25
crates/jacquard-api/src/tools_ozone/set.rs
···
23
23
pub name: jacquard_common::CowStr<'a>,
24
24
}
25
25
26
+
impl jacquard_common::IntoStatic for Set<'_> {
27
+
type Output = Set<'static>;
28
+
fn into_static(self) -> Self::Output {
29
+
Set {
30
+
description: self.description.into_static(),
31
+
name: self.name.into_static(),
32
+
extra_data: self.extra_data.into_static(),
33
+
}
34
+
}
35
+
}
36
+
26
37
#[jacquard_derive::lexicon]
27
38
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
28
39
#[serde(rename_all = "camelCase")]
···
35
46
pub name: jacquard_common::CowStr<'a>,
36
47
pub set_size: i64,
37
48
pub updated_at: jacquard_common::types::string::Datetime,
49
+
}
50
+
51
+
impl jacquard_common::IntoStatic for SetView<'_> {
52
+
type Output = SetView<'static>;
53
+
fn into_static(self) -> Self::Output {
54
+
SetView {
55
+
created_at: self.created_at.into_static(),
56
+
description: self.description.into_static(),
57
+
name: self.name.into_static(),
58
+
set_size: self.set_size.into_static(),
59
+
updated_at: self.updated_at.into_static(),
60
+
extra_data: self.extra_data.into_static(),
61
+
}
62
+
}
38
63
}
+12
-1
crates/jacquard-api/src/tools_ozone/set/add_values.rs
+12
-1
crates/jacquard-api/src/tools_ozone/set/add_values.rs
···
17
17
pub values: Vec<jacquard_common::CowStr<'a>>,
18
18
}
19
19
20
+
impl jacquard_common::IntoStatic for AddValues<'_> {
21
+
type Output = AddValues<'static>;
22
+
fn into_static(self) -> Self::Output {
23
+
AddValues {
24
+
name: self.name.into_static(),
25
+
values: self.values.into_static(),
26
+
extra_data: self.extra_data.into_static(),
27
+
}
28
+
}
29
+
}
30
+
20
31
impl jacquard_common::types::xrpc::XrpcRequest for AddValues<'_> {
21
32
const NSID: &'static str = "tools.ozone.set.addValues";
22
33
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
24
35
);
25
36
const OUTPUT_ENCODING: &'static str = "application/json";
26
37
type Output<'de> = ();
27
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
38
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
28
39
}
+31
crates/jacquard-api/src/tools_ozone/set/delete_set.rs
+31
crates/jacquard-api/src/tools_ozone/set/delete_set.rs
···
14
14
pub name: jacquard_common::CowStr<'a>,
15
15
}
16
16
17
+
impl jacquard_common::IntoStatic for DeleteSet<'_> {
18
+
type Output = DeleteSet<'static>;
19
+
fn into_static(self) -> Self::Output {
20
+
DeleteSet {
21
+
name: self.name.into_static(),
22
+
extra_data: self.extra_data.into_static(),
23
+
}
24
+
}
25
+
}
26
+
17
27
#[jacquard_derive::lexicon]
18
28
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
19
29
#[serde(rename_all = "camelCase")]
20
30
pub struct DeleteSetOutput<'a> {}
31
+
impl jacquard_common::IntoStatic for DeleteSetOutput<'_> {
32
+
type Output = DeleteSetOutput<'static>;
33
+
fn into_static(self) -> Self::Output {
34
+
DeleteSetOutput {
35
+
extra_data: self.extra_data.into_static(),
36
+
}
37
+
}
38
+
}
39
+
21
40
#[jacquard_derive::open_union]
22
41
#[derive(
23
42
serde::Serialize,
···
48
67
Ok(())
49
68
}
50
69
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
70
+
}
71
+
}
72
+
}
73
+
74
+
impl jacquard_common::IntoStatic for DeleteSetError<'_> {
75
+
type Output = DeleteSetError<'static>;
76
+
fn into_static(self) -> Self::Output {
77
+
match self {
78
+
DeleteSetError::SetNotFound(v) => {
79
+
DeleteSetError::SetNotFound(v.into_static())
80
+
}
81
+
DeleteSetError::Unknown(v) => DeleteSetError::Unknown(v.into_static()),
51
82
}
52
83
}
53
84
}
+23
crates/jacquard-api/src/tools_ozone/set/delete_values.rs
+23
crates/jacquard-api/src/tools_ozone/set/delete_values.rs
···
17
17
pub values: Vec<jacquard_common::CowStr<'a>>,
18
18
}
19
19
20
+
impl jacquard_common::IntoStatic for DeleteValues<'_> {
21
+
type Output = DeleteValues<'static>;
22
+
fn into_static(self) -> Self::Output {
23
+
DeleteValues {
24
+
name: self.name.into_static(),
25
+
values: self.values.into_static(),
26
+
extra_data: self.extra_data.into_static(),
27
+
}
28
+
}
29
+
}
30
+
20
31
#[jacquard_derive::open_union]
21
32
#[derive(
22
33
serde::Serialize,
···
47
58
Ok(())
48
59
}
49
60
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
61
+
}
62
+
}
63
+
}
64
+
65
+
impl jacquard_common::IntoStatic for DeleteValuesError<'_> {
66
+
type Output = DeleteValuesError<'static>;
67
+
fn into_static(self) -> Self::Output {
68
+
match self {
69
+
DeleteValuesError::SetNotFound(v) => {
70
+
DeleteValuesError::SetNotFound(v.into_static())
71
+
}
72
+
DeleteValuesError::Unknown(v) => DeleteValuesError::Unknown(v.into_static()),
50
73
}
51
74
}
52
75
}
+33
-7
crates/jacquard-api/src/tools_ozone/set/get_values.rs
+33
-7
crates/jacquard-api/src/tools_ozone/set/get_values.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct GetValues<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
12
#[serde(borrow)]
13
13
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
14
+
///(default: 100, min: 1, max: 1000)
14
15
#[serde(skip_serializing_if = "std::option::Option::is_none")]
15
16
pub limit: std::option::Option<i64>,
16
17
#[serde(borrow)]
17
18
pub name: jacquard_common::CowStr<'a>,
18
19
}
19
20
20
-
impl Default for GetValues<'_> {
21
-
fn default() -> Self {
22
-
Self {
23
-
cursor: Default::default(),
24
-
limit: Some(100i64),
25
-
name: Default::default(),
21
+
impl jacquard_common::IntoStatic for GetValues<'_> {
22
+
type Output = GetValues<'static>;
23
+
fn into_static(self) -> Self::Output {
24
+
GetValues {
25
+
cursor: self.cursor.into_static(),
26
+
limit: self.limit.into_static(),
27
+
name: self.name.into_static(),
26
28
}
27
29
}
28
30
}
···
40
42
pub values: Vec<jacquard_common::CowStr<'a>>,
41
43
}
42
44
45
+
impl jacquard_common::IntoStatic for GetValuesOutput<'_> {
46
+
type Output = GetValuesOutput<'static>;
47
+
fn into_static(self) -> Self::Output {
48
+
GetValuesOutput {
49
+
cursor: self.cursor.into_static(),
50
+
set: self.set.into_static(),
51
+
values: self.values.into_static(),
52
+
extra_data: self.extra_data.into_static(),
53
+
}
54
+
}
55
+
}
56
+
43
57
#[jacquard_derive::open_union]
44
58
#[derive(
45
59
serde::Serialize,
···
70
84
Ok(())
71
85
}
72
86
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
87
+
}
88
+
}
89
+
}
90
+
91
+
impl jacquard_common::IntoStatic for GetValuesError<'_> {
92
+
type Output = GetValuesError<'static>;
93
+
fn into_static(self) -> Self::Output {
94
+
match self {
95
+
GetValuesError::SetNotFound(v) => {
96
+
GetValuesError::SetNotFound(v.into_static())
97
+
}
98
+
GetValuesError::Unknown(v) => GetValuesError::Unknown(v.into_static()),
73
99
}
74
100
}
75
101
}
+25
-10
crates/jacquard-api/src/tools_ozone/set/query_sets.rs
+25
-10
crates/jacquard-api/src/tools_ozone/set/query_sets.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct QuerySets<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
12
#[serde(borrow)]
13
13
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
14
+
///(default: 50, min: 1, max: 100)
14
15
#[serde(skip_serializing_if = "std::option::Option::is_none")]
15
16
pub limit: std::option::Option<i64>,
16
17
#[serde(skip_serializing_if = "std::option::Option::is_none")]
17
18
#[serde(borrow)]
18
19
pub name_prefix: std::option::Option<jacquard_common::CowStr<'a>>,
20
+
///(default: "name")
19
21
#[serde(skip_serializing_if = "std::option::Option::is_none")]
20
22
#[serde(borrow)]
21
23
pub sort_by: std::option::Option<jacquard_common::CowStr<'a>>,
24
+
///(default: "asc")
22
25
#[serde(skip_serializing_if = "std::option::Option::is_none")]
23
26
#[serde(borrow)]
24
27
pub sort_direction: std::option::Option<jacquard_common::CowStr<'a>>,
25
28
}
26
29
27
-
impl Default for QuerySets<'_> {
28
-
fn default() -> Self {
29
-
Self {
30
-
cursor: Default::default(),
31
-
limit: Some(50i64),
32
-
name_prefix: Default::default(),
33
-
sort_by: Some(jacquard_common::CowStr::from("name")),
34
-
sort_direction: Some(jacquard_common::CowStr::from("asc")),
30
+
impl jacquard_common::IntoStatic for QuerySets<'_> {
31
+
type Output = QuerySets<'static>;
32
+
fn into_static(self) -> Self::Output {
33
+
QuerySets {
34
+
cursor: self.cursor.into_static(),
35
+
limit: self.limit.into_static(),
36
+
name_prefix: self.name_prefix.into_static(),
37
+
sort_by: self.sort_by.into_static(),
38
+
sort_direction: self.sort_direction.into_static(),
35
39
}
36
40
}
37
41
}
···
47
51
pub sets: Vec<crate::tools_ozone::set::SetView<'a>>,
48
52
}
49
53
54
+
impl jacquard_common::IntoStatic for QuerySetsOutput<'_> {
55
+
type Output = QuerySetsOutput<'static>;
56
+
fn into_static(self) -> Self::Output {
57
+
QuerySetsOutput {
58
+
cursor: self.cursor.into_static(),
59
+
sets: self.sets.into_static(),
60
+
extra_data: self.extra_data.into_static(),
61
+
}
62
+
}
63
+
}
64
+
50
65
impl jacquard_common::types::xrpc::XrpcRequest for QuerySets<'_> {
51
66
const NSID: &'static str = "tools.ozone.set.querySets";
52
67
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
53
68
const OUTPUT_ENCODING: &'static str = "application/json";
54
69
type Output<'de> = QuerySetsOutput<'de>;
55
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
70
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
56
71
}
+21
-1
crates/jacquard-api/src/tools_ozone/set/upsert_set.rs
+21
-1
crates/jacquard-api/src/tools_ozone/set/upsert_set.rs
···
14
14
pub value: crate::tools_ozone::set::Set<'a>,
15
15
}
16
16
17
+
impl jacquard_common::IntoStatic for UpsertSet<'_> {
18
+
type Output = UpsertSet<'static>;
19
+
fn into_static(self) -> Self::Output {
20
+
UpsertSet {
21
+
value: self.value.into_static(),
22
+
extra_data: self.extra_data.into_static(),
23
+
}
24
+
}
25
+
}
26
+
17
27
#[jacquard_derive::lexicon]
18
28
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
19
29
#[serde(rename_all = "camelCase")]
···
23
33
pub value: crate::tools_ozone::set::SetView<'a>,
24
34
}
25
35
36
+
impl jacquard_common::IntoStatic for UpsertSetOutput<'_> {
37
+
type Output = UpsertSetOutput<'static>;
38
+
fn into_static(self) -> Self::Output {
39
+
UpsertSetOutput {
40
+
value: self.value.into_static(),
41
+
extra_data: self.extra_data.into_static(),
42
+
}
43
+
}
44
+
}
45
+
26
46
impl jacquard_common::types::xrpc::XrpcRequest for UpsertSet<'_> {
27
47
const NSID: &'static str = "tools.ozone.set.upsertSet";
28
48
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
30
50
);
31
51
const OUTPUT_ENCODING: &'static str = "application/json";
32
52
type Output<'de> = UpsertSetOutput<'de>;
33
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
53
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
34
54
}
+19
crates/jacquard-api/src/tools_ozone/setting.rs
+19
crates/jacquard-api/src/tools_ozone/setting.rs
···
35
35
pub updated_at: std::option::Option<jacquard_common::types::string::Datetime>,
36
36
#[serde(borrow)]
37
37
pub value: jacquard_common::types::value::Data<'a>,
38
+
}
39
+
40
+
impl jacquard_common::IntoStatic for Option<'_> {
41
+
type Output = Option<'static>;
42
+
fn into_static(self) -> Self::Output {
43
+
Option {
44
+
created_at: self.created_at.into_static(),
45
+
created_by: self.created_by.into_static(),
46
+
description: self.description.into_static(),
47
+
did: self.did.into_static(),
48
+
key: self.key.into_static(),
49
+
last_updated_by: self.last_updated_by.into_static(),
50
+
manager_role: self.manager_role.into_static(),
51
+
scope: self.scope.into_static(),
52
+
updated_at: self.updated_at.into_static(),
53
+
value: self.value.into_static(),
54
+
extra_data: self.extra_data.into_static(),
55
+
}
56
+
}
38
57
}
+24
-10
crates/jacquard-api/src/tools_ozone/setting/list_options.rs
+24
-10
crates/jacquard-api/src/tools_ozone/setting/list_options.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct ListOptions<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
14
14
#[serde(skip_serializing_if = "std::option::Option::is_none")]
15
15
#[serde(borrow)]
16
16
pub keys: std::option::Option<Vec<jacquard_common::types::string::Nsid<'a>>>,
17
+
///(default: 50, min: 1, max: 100)
17
18
#[serde(skip_serializing_if = "std::option::Option::is_none")]
18
19
pub limit: std::option::Option<i64>,
19
20
#[serde(skip_serializing_if = "std::option::Option::is_none")]
20
21
#[serde(borrow)]
21
22
pub prefix: std::option::Option<jacquard_common::CowStr<'a>>,
23
+
///(default: "instance")
22
24
#[serde(skip_serializing_if = "std::option::Option::is_none")]
23
25
#[serde(borrow)]
24
26
pub scope: std::option::Option<jacquard_common::CowStr<'a>>,
25
27
}
26
28
27
-
impl Default for ListOptions<'_> {
28
-
fn default() -> Self {
29
-
Self {
30
-
cursor: Default::default(),
31
-
keys: Default::default(),
32
-
limit: Some(50i64),
33
-
prefix: Default::default(),
34
-
scope: Some(jacquard_common::CowStr::from("instance")),
29
+
impl jacquard_common::IntoStatic for ListOptions<'_> {
30
+
type Output = ListOptions<'static>;
31
+
fn into_static(self) -> Self::Output {
32
+
ListOptions {
33
+
cursor: self.cursor.into_static(),
34
+
keys: self.keys.into_static(),
35
+
limit: self.limit.into_static(),
36
+
prefix: self.prefix.into_static(),
37
+
scope: self.scope.into_static(),
35
38
}
36
39
}
37
40
}
···
47
50
pub options: Vec<crate::tools_ozone::setting::Option<'a>>,
48
51
}
49
52
53
+
impl jacquard_common::IntoStatic for ListOptionsOutput<'_> {
54
+
type Output = ListOptionsOutput<'static>;
55
+
fn into_static(self) -> Self::Output {
56
+
ListOptionsOutput {
57
+
cursor: self.cursor.into_static(),
58
+
options: self.options.into_static(),
59
+
extra_data: self.extra_data.into_static(),
60
+
}
61
+
}
62
+
}
63
+
50
64
impl jacquard_common::types::xrpc::XrpcRequest for ListOptions<'_> {
51
65
const NSID: &'static str = "tools.ozone.setting.listOptions";
52
66
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
53
67
const OUTPUT_ENCODING: &'static str = "application/json";
54
68
type Output<'de> = ListOptionsOutput<'de>;
55
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
69
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
56
70
}
+21
-1
crates/jacquard-api/src/tools_ozone/setting/remove_options.rs
+21
-1
crates/jacquard-api/src/tools_ozone/setting/remove_options.rs
···
15
15
pub scope: jacquard_common::CowStr<'a>,
16
16
}
17
17
18
+
impl jacquard_common::IntoStatic for RemoveOptions<'_> {
19
+
type Output = RemoveOptions<'static>;
20
+
fn into_static(self) -> Self::Output {
21
+
RemoveOptions {
22
+
keys: self.keys.into_static(),
23
+
scope: self.scope.into_static(),
24
+
extra_data: self.extra_data.into_static(),
25
+
}
26
+
}
27
+
}
28
+
18
29
#[jacquard_derive::lexicon]
19
30
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
20
31
#[serde(rename_all = "camelCase")]
21
32
pub struct RemoveOptionsOutput<'a> {}
33
+
impl jacquard_common::IntoStatic for RemoveOptionsOutput<'_> {
34
+
type Output = RemoveOptionsOutput<'static>;
35
+
fn into_static(self) -> Self::Output {
36
+
RemoveOptionsOutput {
37
+
extra_data: self.extra_data.into_static(),
38
+
}
39
+
}
40
+
}
41
+
22
42
impl jacquard_common::types::xrpc::XrpcRequest for RemoveOptions<'_> {
23
43
const NSID: &'static str = "tools.ozone.setting.removeOptions";
24
44
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
26
46
);
27
47
const OUTPUT_ENCODING: &'static str = "application/json";
28
48
type Output<'de> = RemoveOptionsOutput<'de>;
29
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
49
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
30
50
}
+25
-1
crates/jacquard-api/src/tools_ozone/setting/upsert_option.rs
+25
-1
crates/jacquard-api/src/tools_ozone/setting/upsert_option.rs
···
23
23
pub value: jacquard_common::types::value::Data<'a>,
24
24
}
25
25
26
+
impl jacquard_common::IntoStatic for UpsertOption<'_> {
27
+
type Output = UpsertOption<'static>;
28
+
fn into_static(self) -> Self::Output {
29
+
UpsertOption {
30
+
description: self.description.into_static(),
31
+
key: self.key.into_static(),
32
+
manager_role: self.manager_role.into_static(),
33
+
scope: self.scope.into_static(),
34
+
value: self.value.into_static(),
35
+
extra_data: self.extra_data.into_static(),
36
+
}
37
+
}
38
+
}
39
+
26
40
#[jacquard_derive::lexicon]
27
41
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
28
42
#[serde(rename_all = "camelCase")]
···
31
45
pub option: crate::tools_ozone::setting::Option<'a>,
32
46
}
33
47
48
+
impl jacquard_common::IntoStatic for UpsertOptionOutput<'_> {
49
+
type Output = UpsertOptionOutput<'static>;
50
+
fn into_static(self) -> Self::Output {
51
+
UpsertOptionOutput {
52
+
option: self.option.into_static(),
53
+
extra_data: self.extra_data.into_static(),
54
+
}
55
+
}
56
+
}
57
+
34
58
impl jacquard_common::types::xrpc::XrpcRequest for UpsertOption<'_> {
35
59
const NSID: &'static str = "tools.ozone.setting.upsertOption";
36
60
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
38
62
);
39
63
const OUTPUT_ENCODING: &'static str = "application/json";
40
64
type Output<'de> = UpsertOptionOutput<'de>;
41
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
65
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
42
66
}
+11
crates/jacquard-api/src/tools_ozone/signature.rs
+11
crates/jacquard-api/src/tools_ozone/signature.rs
···
17
17
pub property: jacquard_common::CowStr<'a>,
18
18
#[serde(borrow)]
19
19
pub value: jacquard_common::CowStr<'a>,
20
+
}
21
+
22
+
impl jacquard_common::IntoStatic for SigDetail<'_> {
23
+
type Output = SigDetail<'static>;
24
+
fn into_static(self) -> Self::Output {
25
+
SigDetail {
26
+
property: self.property.into_static(),
27
+
value: self.value.into_static(),
28
+
extra_data: self.extra_data.into_static(),
29
+
}
30
+
}
20
31
}
+20
-1
crates/jacquard-api/src/tools_ozone/signature/find_correlation.rs
+20
-1
crates/jacquard-api/src/tools_ozone/signature/find_correlation.rs
···
12
12
pub dids: Vec<jacquard_common::types::string::Did<'a>>,
13
13
}
14
14
15
+
impl jacquard_common::IntoStatic for FindCorrelation<'_> {
16
+
type Output = FindCorrelation<'static>;
17
+
fn into_static(self) -> Self::Output {
18
+
FindCorrelation {
19
+
dids: self.dids.into_static(),
20
+
}
21
+
}
22
+
}
23
+
15
24
#[jacquard_derive::lexicon]
16
25
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
17
26
#[serde(rename_all = "camelCase")]
···
20
29
pub details: Vec<crate::tools_ozone::signature::SigDetail<'a>>,
21
30
}
22
31
32
+
impl jacquard_common::IntoStatic for FindCorrelationOutput<'_> {
33
+
type Output = FindCorrelationOutput<'static>;
34
+
fn into_static(self) -> Self::Output {
35
+
FindCorrelationOutput {
36
+
details: self.details.into_static(),
37
+
extra_data: self.extra_data.into_static(),
38
+
}
39
+
}
40
+
}
41
+
23
42
impl jacquard_common::types::xrpc::XrpcRequest for FindCorrelation<'_> {
24
43
const NSID: &'static str = "tools.ozone.signature.findCorrelation";
25
44
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
26
45
const OUTPUT_ENCODING: &'static str = "application/json";
27
46
type Output<'de> = FindCorrelationOutput<'de>;
28
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
47
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
29
48
}
+21
-8
crates/jacquard-api/src/tools_ozone/signature/search_accounts.rs
+21
-8
crates/jacquard-api/src/tools_ozone/signature/search_accounts.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct SearchAccounts<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
12
12
#[serde(borrow)]
13
13
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
14
+
///(default: 50, min: 1, max: 100)
14
15
#[serde(skip_serializing_if = "std::option::Option::is_none")]
15
16
pub limit: std::option::Option<i64>,
16
17
#[serde(borrow)]
17
18
pub values: Vec<jacquard_common::CowStr<'a>>,
18
19
}
19
20
20
-
impl Default for SearchAccounts<'_> {
21
-
fn default() -> Self {
22
-
Self {
23
-
cursor: Default::default(),
24
-
limit: Some(50i64),
25
-
values: Default::default(),
21
+
impl jacquard_common::IntoStatic for SearchAccounts<'_> {
22
+
type Output = SearchAccounts<'static>;
23
+
fn into_static(self) -> Self::Output {
24
+
SearchAccounts {
25
+
cursor: self.cursor.into_static(),
26
+
limit: self.limit.into_static(),
27
+
values: self.values.into_static(),
26
28
}
27
29
}
28
30
}
···
38
40
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
39
41
}
40
42
43
+
impl jacquard_common::IntoStatic for SearchAccountsOutput<'_> {
44
+
type Output = SearchAccountsOutput<'static>;
45
+
fn into_static(self) -> Self::Output {
46
+
SearchAccountsOutput {
47
+
accounts: self.accounts.into_static(),
48
+
cursor: self.cursor.into_static(),
49
+
extra_data: self.extra_data.into_static(),
50
+
}
51
+
}
52
+
}
53
+
41
54
impl jacquard_common::types::xrpc::XrpcRequest for SearchAccounts<'_> {
42
55
const NSID: &'static str = "tools.ozone.signature.searchAccounts";
43
56
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
44
57
const OUTPUT_ENCODING: &'static str = "application/json";
45
58
type Output<'de> = SearchAccountsOutput<'de>;
46
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
59
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
47
60
}
+16
crates/jacquard-api/src/tools_ozone/team.rs
+16
crates/jacquard-api/src/tools_ozone/team.rs
···
30
30
pub role: jacquard_common::CowStr<'a>,
31
31
#[serde(skip_serializing_if = "std::option::Option::is_none")]
32
32
pub updated_at: std::option::Option<jacquard_common::types::string::Datetime>,
33
+
}
34
+
35
+
impl jacquard_common::IntoStatic for Member<'_> {
36
+
type Output = Member<'static>;
37
+
fn into_static(self) -> Self::Output {
38
+
Member {
39
+
created_at: self.created_at.into_static(),
40
+
did: self.did.into_static(),
41
+
disabled: self.disabled.into_static(),
42
+
last_updated_by: self.last_updated_by.into_static(),
43
+
profile: self.profile.into_static(),
44
+
role: self.role.into_static(),
45
+
updated_at: self.updated_at.into_static(),
46
+
extra_data: self.extra_data.into_static(),
47
+
}
48
+
}
33
49
}
+33
crates/jacquard-api/src/tools_ozone/team/add_member.rs
+33
crates/jacquard-api/src/tools_ozone/team/add_member.rs
···
15
15
pub role: jacquard_common::CowStr<'a>,
16
16
}
17
17
18
+
impl jacquard_common::IntoStatic for AddMember<'_> {
19
+
type Output = AddMember<'static>;
20
+
fn into_static(self) -> Self::Output {
21
+
AddMember {
22
+
did: self.did.into_static(),
23
+
role: self.role.into_static(),
24
+
extra_data: self.extra_data.into_static(),
25
+
}
26
+
}
27
+
}
28
+
18
29
#[jacquard_derive::lexicon]
19
30
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
20
31
#[serde(rename_all = "camelCase")]
···
24
35
pub value: crate::tools_ozone::team::Member<'a>,
25
36
}
26
37
38
+
impl jacquard_common::IntoStatic for AddMemberOutput<'_> {
39
+
type Output = AddMemberOutput<'static>;
40
+
fn into_static(self) -> Self::Output {
41
+
AddMemberOutput {
42
+
value: self.value.into_static(),
43
+
extra_data: self.extra_data.into_static(),
44
+
}
45
+
}
46
+
}
47
+
27
48
#[jacquard_derive::open_union]
28
49
#[derive(
29
50
serde::Serialize,
···
54
75
Ok(())
55
76
}
56
77
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
78
+
}
79
+
}
80
+
}
81
+
82
+
impl jacquard_common::IntoStatic for AddMemberError<'_> {
83
+
type Output = AddMemberError<'static>;
84
+
fn into_static(self) -> Self::Output {
85
+
match self {
86
+
AddMemberError::MemberAlreadyExists(v) => {
87
+
AddMemberError::MemberAlreadyExists(v.into_static())
88
+
}
89
+
AddMemberError::Unknown(v) => AddMemberError::Unknown(v.into_static()),
57
90
}
58
91
}
59
92
}
+25
crates/jacquard-api/src/tools_ozone/team/delete_member.rs
+25
crates/jacquard-api/src/tools_ozone/team/delete_member.rs
···
13
13
pub did: jacquard_common::types::string::Did<'a>,
14
14
}
15
15
16
+
impl jacquard_common::IntoStatic for DeleteMember<'_> {
17
+
type Output = DeleteMember<'static>;
18
+
fn into_static(self) -> Self::Output {
19
+
DeleteMember {
20
+
did: self.did.into_static(),
21
+
extra_data: self.extra_data.into_static(),
22
+
}
23
+
}
24
+
}
25
+
16
26
#[jacquard_derive::open_union]
17
27
#[derive(
18
28
serde::Serialize,
···
53
63
Ok(())
54
64
}
55
65
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
66
+
}
67
+
}
68
+
}
69
+
70
+
impl jacquard_common::IntoStatic for DeleteMemberError<'_> {
71
+
type Output = DeleteMemberError<'static>;
72
+
fn into_static(self) -> Self::Output {
73
+
match self {
74
+
DeleteMemberError::MemberNotFound(v) => {
75
+
DeleteMemberError::MemberNotFound(v.into_static())
76
+
}
77
+
DeleteMemberError::CannotDeleteSelf(v) => {
78
+
DeleteMemberError::CannotDeleteSelf(v.into_static())
79
+
}
80
+
DeleteMemberError::Unknown(v) => DeleteMemberError::Unknown(v.into_static()),
56
81
}
57
82
}
58
83
}
+23
-10
crates/jacquard-api/src/tools_ozone/team/list_members.rs
+23
-10
crates/jacquard-api/src/tools_ozone/team/list_members.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct ListMembers<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
13
13
pub cursor: std::option::Option<jacquard_common::CowStr<'a>>,
14
14
#[serde(skip_serializing_if = "std::option::Option::is_none")]
15
15
pub disabled: std::option::Option<bool>,
16
+
///(default: 50, min: 1, max: 100)
16
17
#[serde(skip_serializing_if = "std::option::Option::is_none")]
17
18
pub limit: std::option::Option<i64>,
18
19
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
23
24
pub roles: std::option::Option<Vec<jacquard_common::CowStr<'a>>>,
24
25
}
25
26
26
-
impl Default for ListMembers<'_> {
27
-
fn default() -> Self {
28
-
Self {
29
-
cursor: Default::default(),
30
-
disabled: Default::default(),
31
-
limit: Some(50i64),
32
-
q: Default::default(),
33
-
roles: Default::default(),
27
+
impl jacquard_common::IntoStatic for ListMembers<'_> {
28
+
type Output = ListMembers<'static>;
29
+
fn into_static(self) -> Self::Output {
30
+
ListMembers {
31
+
cursor: self.cursor.into_static(),
32
+
disabled: self.disabled.into_static(),
33
+
limit: self.limit.into_static(),
34
+
q: self.q.into_static(),
35
+
roles: self.roles.into_static(),
34
36
}
35
37
}
36
38
}
···
46
48
pub members: Vec<crate::tools_ozone::team::Member<'a>>,
47
49
}
48
50
51
+
impl jacquard_common::IntoStatic for ListMembersOutput<'_> {
52
+
type Output = ListMembersOutput<'static>;
53
+
fn into_static(self) -> Self::Output {
54
+
ListMembersOutput {
55
+
cursor: self.cursor.into_static(),
56
+
members: self.members.into_static(),
57
+
extra_data: self.extra_data.into_static(),
58
+
}
59
+
}
60
+
}
61
+
49
62
impl jacquard_common::types::xrpc::XrpcRequest for ListMembers<'_> {
50
63
const NSID: &'static str = "tools.ozone.team.listMembers";
51
64
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
52
65
const OUTPUT_ENCODING: &'static str = "application/json";
53
66
type Output<'de> = ListMembersOutput<'de>;
54
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
67
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
55
68
}
+34
crates/jacquard-api/src/tools_ozone/team/update_member.rs
+34
crates/jacquard-api/src/tools_ozone/team/update_member.rs
···
18
18
pub role: std::option::Option<jacquard_common::CowStr<'a>>,
19
19
}
20
20
21
+
impl jacquard_common::IntoStatic for UpdateMember<'_> {
22
+
type Output = UpdateMember<'static>;
23
+
fn into_static(self) -> Self::Output {
24
+
UpdateMember {
25
+
did: self.did.into_static(),
26
+
disabled: self.disabled.into_static(),
27
+
role: self.role.into_static(),
28
+
extra_data: self.extra_data.into_static(),
29
+
}
30
+
}
31
+
}
32
+
21
33
#[jacquard_derive::lexicon]
22
34
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
23
35
#[serde(rename_all = "camelCase")]
···
27
39
pub value: crate::tools_ozone::team::Member<'a>,
28
40
}
29
41
42
+
impl jacquard_common::IntoStatic for UpdateMemberOutput<'_> {
43
+
type Output = UpdateMemberOutput<'static>;
44
+
fn into_static(self) -> Self::Output {
45
+
UpdateMemberOutput {
46
+
value: self.value.into_static(),
47
+
extra_data: self.extra_data.into_static(),
48
+
}
49
+
}
50
+
}
51
+
30
52
#[jacquard_derive::open_union]
31
53
#[derive(
32
54
serde::Serialize,
···
57
79
Ok(())
58
80
}
59
81
Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
82
+
}
83
+
}
84
+
}
85
+
86
+
impl jacquard_common::IntoStatic for UpdateMemberError<'_> {
87
+
type Output = UpdateMemberError<'static>;
88
+
fn into_static(self) -> Self::Output {
89
+
match self {
90
+
UpdateMemberError::MemberNotFound(v) => {
91
+
UpdateMemberError::MemberNotFound(v.into_static())
92
+
}
93
+
UpdateMemberError::Unknown(v) => UpdateMemberError::Unknown(v.into_static()),
60
94
}
61
95
}
62
96
}
+78
crates/jacquard-api/src/tools_ozone/verification.rs
+78
crates/jacquard-api/src/tools_ozone/verification.rs
···
61
61
#[serde(tag = "$type")]
62
62
#[serde(bound(deserialize = "'de: 'a"))]
63
63
pub enum VerificationViewRecordIssuerProfile<'a> {}
64
+
impl jacquard_common::IntoStatic for VerificationViewRecordIssuerProfile<'_> {
65
+
type Output = VerificationViewRecordIssuerProfile<'static>;
66
+
fn into_static(self) -> Self::Output {
67
+
match self {
68
+
VerificationViewRecordIssuerProfile::Unknown(v) => {
69
+
VerificationViewRecordIssuerProfile::Unknown(v.into_static())
70
+
}
71
+
}
72
+
}
73
+
}
74
+
64
75
#[jacquard_derive::open_union]
65
76
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
66
77
#[serde(tag = "$type")]
···
72
83
DefsRepoViewNotFound(Box<crate::tools_ozone::moderation::RepoViewNotFound<'a>>),
73
84
}
74
85
86
+
impl jacquard_common::IntoStatic for VerificationViewRecordIssuerRepo<'_> {
87
+
type Output = VerificationViewRecordIssuerRepo<'static>;
88
+
fn into_static(self) -> Self::Output {
89
+
match self {
90
+
VerificationViewRecordIssuerRepo::DefsRepoViewDetail(v) => {
91
+
VerificationViewRecordIssuerRepo::DefsRepoViewDetail(v.into_static())
92
+
}
93
+
VerificationViewRecordIssuerRepo::DefsRepoViewNotFound(v) => {
94
+
VerificationViewRecordIssuerRepo::DefsRepoViewNotFound(v.into_static())
95
+
}
96
+
VerificationViewRecordIssuerRepo::Unknown(v) => {
97
+
VerificationViewRecordIssuerRepo::Unknown(v.into_static())
98
+
}
99
+
}
100
+
}
101
+
}
102
+
75
103
#[jacquard_derive::open_union]
76
104
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
77
105
#[serde(tag = "$type")]
78
106
#[serde(bound(deserialize = "'de: 'a"))]
79
107
pub enum VerificationViewRecordSubjectProfile<'a> {}
108
+
impl jacquard_common::IntoStatic for VerificationViewRecordSubjectProfile<'_> {
109
+
type Output = VerificationViewRecordSubjectProfile<'static>;
110
+
fn into_static(self) -> Self::Output {
111
+
match self {
112
+
VerificationViewRecordSubjectProfile::Unknown(v) => {
113
+
VerificationViewRecordSubjectProfile::Unknown(v.into_static())
114
+
}
115
+
}
116
+
}
117
+
}
118
+
80
119
#[jacquard_derive::open_union]
81
120
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
82
121
#[serde(tag = "$type")]
···
86
125
DefsRepoViewDetail(Box<crate::tools_ozone::moderation::RepoViewDetail<'a>>),
87
126
#[serde(rename = "tools.ozone.moderation.defs#repoViewNotFound")]
88
127
DefsRepoViewNotFound(Box<crate::tools_ozone::moderation::RepoViewNotFound<'a>>),
128
+
}
129
+
130
+
impl jacquard_common::IntoStatic for VerificationViewRecordSubjectRepo<'_> {
131
+
type Output = VerificationViewRecordSubjectRepo<'static>;
132
+
fn into_static(self) -> Self::Output {
133
+
match self {
134
+
VerificationViewRecordSubjectRepo::DefsRepoViewDetail(v) => {
135
+
VerificationViewRecordSubjectRepo::DefsRepoViewDetail(v.into_static())
136
+
}
137
+
VerificationViewRecordSubjectRepo::DefsRepoViewNotFound(v) => {
138
+
VerificationViewRecordSubjectRepo::DefsRepoViewNotFound(v.into_static())
139
+
}
140
+
VerificationViewRecordSubjectRepo::Unknown(v) => {
141
+
VerificationViewRecordSubjectRepo::Unknown(v.into_static())
142
+
}
143
+
}
144
+
}
145
+
}
146
+
147
+
impl jacquard_common::IntoStatic for VerificationView<'_> {
148
+
type Output = VerificationView<'static>;
149
+
fn into_static(self) -> Self::Output {
150
+
VerificationView {
151
+
created_at: self.created_at.into_static(),
152
+
display_name: self.display_name.into_static(),
153
+
handle: self.handle.into_static(),
154
+
issuer: self.issuer.into_static(),
155
+
issuer_profile: self.issuer_profile.into_static(),
156
+
issuer_repo: self.issuer_repo.into_static(),
157
+
revoke_reason: self.revoke_reason.into_static(),
158
+
revoked_at: self.revoked_at.into_static(),
159
+
revoked_by: self.revoked_by.into_static(),
160
+
subject: self.subject.into_static(),
161
+
subject_profile: self.subject_profile.into_static(),
162
+
subject_repo: self.subject_repo.into_static(),
163
+
uri: self.uri.into_static(),
164
+
extra_data: self.extra_data.into_static(),
165
+
}
166
+
}
89
167
}
+46
-1
crates/jacquard-api/src/tools_ozone/verification/grant_verifications.rs
+46
-1
crates/jacquard-api/src/tools_ozone/verification/grant_verifications.rs
···
18
18
pub subject: jacquard_common::types::string::Did<'a>,
19
19
}
20
20
21
+
impl jacquard_common::IntoStatic for GrantError<'_> {
22
+
type Output = GrantError<'static>;
23
+
fn into_static(self) -> Self::Output {
24
+
GrantError {
25
+
error: self.error.into_static(),
26
+
subject: self.subject.into_static(),
27
+
extra_data: self.extra_data.into_static(),
28
+
}
29
+
}
30
+
}
31
+
21
32
#[jacquard_derive::lexicon]
22
33
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
23
34
#[serde(rename_all = "camelCase")]
···
27
38
pub verifications: Vec<jacquard_common::types::value::Data<'a>>,
28
39
}
29
40
41
+
impl jacquard_common::IntoStatic for GrantVerifications<'_> {
42
+
type Output = GrantVerifications<'static>;
43
+
fn into_static(self) -> Self::Output {
44
+
GrantVerifications {
45
+
verifications: self.verifications.into_static(),
46
+
extra_data: self.extra_data.into_static(),
47
+
}
48
+
}
49
+
}
50
+
30
51
#[jacquard_derive::lexicon]
31
52
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
32
53
#[serde(rename_all = "camelCase")]
···
37
58
pub verifications: Vec<crate::tools_ozone::verification::VerificationView<'a>>,
38
59
}
39
60
61
+
impl jacquard_common::IntoStatic for GrantVerificationsOutput<'_> {
62
+
type Output = GrantVerificationsOutput<'static>;
63
+
fn into_static(self) -> Self::Output {
64
+
GrantVerificationsOutput {
65
+
failed_verifications: self.failed_verifications.into_static(),
66
+
verifications: self.verifications.into_static(),
67
+
extra_data: self.extra_data.into_static(),
68
+
}
69
+
}
70
+
}
71
+
40
72
impl jacquard_common::types::xrpc::XrpcRequest for GrantVerifications<'_> {
41
73
const NSID: &'static str = "tools.ozone.verification.grantVerifications";
42
74
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
44
76
);
45
77
const OUTPUT_ENCODING: &'static str = "application/json";
46
78
type Output<'de> = GrantVerificationsOutput<'de>;
47
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
79
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
48
80
}
49
81
50
82
#[jacquard_derive::lexicon]
···
63
95
///The did of the subject being verified
64
96
#[serde(borrow)]
65
97
pub subject: jacquard_common::types::string::Did<'a>,
98
+
}
99
+
100
+
impl jacquard_common::IntoStatic for VerificationInput<'_> {
101
+
type Output = VerificationInput<'static>;
102
+
fn into_static(self) -> Self::Output {
103
+
VerificationInput {
104
+
created_at: self.created_at.into_static(),
105
+
display_name: self.display_name.into_static(),
106
+
handle: self.handle.into_static(),
107
+
subject: self.subject.into_static(),
108
+
extra_data: self.extra_data.into_static(),
109
+
}
110
+
}
66
111
}
+27
-13
crates/jacquard-api/src/tools_ozone/verification/list_verifications.rs
+27
-13
crates/jacquard-api/src/tools_ozone/verification/list_verifications.rs
···
5
5
// This file was automatically generated from Lexicon schemas.
6
6
// Any manual changes will be overwritten on the next regeneration.
7
7
8
-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)]
8
+
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
9
9
#[serde(rename_all = "camelCase")]
10
10
pub struct ListVerifications<'a> {
11
11
#[serde(skip_serializing_if = "std::option::Option::is_none")]
···
20
20
#[serde(skip_serializing_if = "std::option::Option::is_none")]
21
21
#[serde(borrow)]
22
22
pub issuers: std::option::Option<Vec<jacquard_common::types::string::Did<'a>>>,
23
+
///(default: 50, min: 1, max: 100)
23
24
#[serde(skip_serializing_if = "std::option::Option::is_none")]
24
25
pub limit: std::option::Option<i64>,
26
+
///(default: "desc")
25
27
#[serde(skip_serializing_if = "std::option::Option::is_none")]
26
28
#[serde(borrow)]
27
29
pub sort_direction: std::option::Option<jacquard_common::CowStr<'a>>,
···
30
32
pub subjects: std::option::Option<Vec<jacquard_common::types::string::Did<'a>>>,
31
33
}
32
34
33
-
impl Default for ListVerifications<'_> {
34
-
fn default() -> Self {
35
-
Self {
36
-
created_after: Default::default(),
37
-
created_before: Default::default(),
38
-
cursor: Default::default(),
39
-
is_revoked: Default::default(),
40
-
issuers: Default::default(),
41
-
limit: Some(50i64),
42
-
sort_direction: Some(jacquard_common::CowStr::from("desc")),
43
-
subjects: Default::default(),
35
+
impl jacquard_common::IntoStatic for ListVerifications<'_> {
36
+
type Output = ListVerifications<'static>;
37
+
fn into_static(self) -> Self::Output {
38
+
ListVerifications {
39
+
created_after: self.created_after.into_static(),
40
+
created_before: self.created_before.into_static(),
41
+
cursor: self.cursor.into_static(),
42
+
is_revoked: self.is_revoked.into_static(),
43
+
issuers: self.issuers.into_static(),
44
+
limit: self.limit.into_static(),
45
+
sort_direction: self.sort_direction.into_static(),
46
+
subjects: self.subjects.into_static(),
44
47
}
45
48
}
46
49
}
···
56
59
pub verifications: Vec<crate::tools_ozone::verification::VerificationView<'a>>,
57
60
}
58
61
62
+
impl jacquard_common::IntoStatic for ListVerificationsOutput<'_> {
63
+
type Output = ListVerificationsOutput<'static>;
64
+
fn into_static(self) -> Self::Output {
65
+
ListVerificationsOutput {
66
+
cursor: self.cursor.into_static(),
67
+
verifications: self.verifications.into_static(),
68
+
extra_data: self.extra_data.into_static(),
69
+
}
70
+
}
71
+
}
72
+
59
73
impl jacquard_common::types::xrpc::XrpcRequest for ListVerifications<'_> {
60
74
const NSID: &'static str = "tools.ozone.verification.listVerifications";
61
75
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Query;
62
76
const OUTPUT_ENCODING: &'static str = "application/json";
63
77
type Output<'de> = ListVerificationsOutput<'de>;
64
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
78
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
65
79
}
+34
-1
crates/jacquard-api/src/tools_ozone/verification/revoke_verifications.rs
+34
-1
crates/jacquard-api/src/tools_ozone/verification/revoke_verifications.rs
···
18
18
pub uris: Vec<jacquard_common::types::string::AtUri<'a>>,
19
19
}
20
20
21
+
impl jacquard_common::IntoStatic for RevokeVerifications<'_> {
22
+
type Output = RevokeVerifications<'static>;
23
+
fn into_static(self) -> Self::Output {
24
+
RevokeVerifications {
25
+
revoke_reason: self.revoke_reason.into_static(),
26
+
uris: self.uris.into_static(),
27
+
extra_data: self.extra_data.into_static(),
28
+
}
29
+
}
30
+
}
31
+
21
32
#[jacquard_derive::lexicon]
22
33
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
23
34
#[serde(rename_all = "camelCase")]
···
30
41
pub revoked_verifications: Vec<jacquard_common::types::string::AtUri<'a>>,
31
42
}
32
43
44
+
impl jacquard_common::IntoStatic for RevokeVerificationsOutput<'_> {
45
+
type Output = RevokeVerificationsOutput<'static>;
46
+
fn into_static(self) -> Self::Output {
47
+
RevokeVerificationsOutput {
48
+
failed_revocations: self.failed_revocations.into_static(),
49
+
revoked_verifications: self.revoked_verifications.into_static(),
50
+
extra_data: self.extra_data.into_static(),
51
+
}
52
+
}
53
+
}
54
+
33
55
impl jacquard_common::types::xrpc::XrpcRequest for RevokeVerifications<'_> {
34
56
const NSID: &'static str = "tools.ozone.verification.revokeVerifications";
35
57
const METHOD: jacquard_common::types::xrpc::XrpcMethod = jacquard_common::types::xrpc::XrpcMethod::Procedure(
···
37
59
);
38
60
const OUTPUT_ENCODING: &'static str = "application/json";
39
61
type Output<'de> = RevokeVerificationsOutput<'de>;
40
-
type Err<'de> = jacquard_common::types::xrpc::GenericError;
62
+
type Err<'de> = jacquard_common::types::xrpc::GenericError<'de>;
41
63
}
42
64
43
65
///Error object for failed revocations
···
51
73
///The AT-URI of the verification record that failed to revoke.
52
74
#[serde(borrow)]
53
75
pub uri: jacquard_common::types::string::AtUri<'a>,
76
+
}
77
+
78
+
impl jacquard_common::IntoStatic for RevokeError<'_> {
79
+
type Output = RevokeError<'static>;
80
+
fn into_static(self) -> Self::Output {
81
+
RevokeError {
82
+
error: self.error.into_static(),
83
+
uri: self.uri.into_static(),
84
+
extra_data: self.extra_data.into_static(),
85
+
}
86
+
}
54
87
}
+16
crates/jacquard-common/src/into_static.rs
+16
crates/jacquard-common/src/into_static.rs
···
96
96
}
97
97
}
98
98
99
+
impl IntoStatic for bytes::Bytes {
100
+
type Output = bytes::Bytes;
101
+
102
+
fn into_static(self) -> Self::Output {
103
+
self
104
+
}
105
+
}
106
+
107
+
impl IntoStatic for () {
108
+
type Output = ();
109
+
110
+
fn into_static(self) -> Self::Output {
111
+
self
112
+
}
113
+
}
114
+
99
115
impl<T: IntoStatic> IntoStatic for Option<T> {
100
116
type Output = Option<T::Output>;
101
117
+8
crates/jacquard-common/src/types/datetime.rs
+8
crates/jacquard-common/src/types/datetime.rs
+8
crates/jacquard-common/src/types/language.rs
+8
crates/jacquard-common/src/types/language.rs
+8
crates/jacquard-common/src/types/tid.rs
+8
crates/jacquard-common/src/types/tid.rs
+35
-1
crates/jacquard-common/src/types/value.rs
+35
-1
crates/jacquard-common/src/types/value.rs
···
1
-
use crate::types::{DataModelType, LexiconStringType, UriType, blob::Blob, string::*};
1
+
use crate::{
2
+
IntoStatic,
3
+
types::{DataModelType, LexiconStringType, UriType, blob::Blob, string::*},
4
+
};
2
5
use bytes::Bytes;
3
6
use ipld_core::ipld::Ipld;
4
7
use smol_str::{SmolStr, ToSmolStr};
···
101
104
}
102
105
}
103
106
107
+
impl IntoStatic for Data<'_> {
108
+
type Output = Data<'static>;
109
+
fn into_static(self) -> Data<'static> {
110
+
match self {
111
+
Data::Null => Data::Null,
112
+
Data::Boolean(bool) => Data::Boolean(bool),
113
+
Data::Integer(int) => Data::Integer(int),
114
+
Data::String(string) => Data::String(string.into_static()),
115
+
Data::Bytes(bytes) => Data::Bytes(bytes),
116
+
Data::Array(array) => Data::Array(array.into_static()),
117
+
Data::Object(object) => Data::Object(object.into_static()),
118
+
Data::CidLink(cid) => Data::CidLink(cid.into_static()),
119
+
Data::Blob(blob) => Data::Blob(blob.into_static()),
120
+
}
121
+
}
122
+
}
123
+
104
124
#[derive(Debug, Clone, PartialEq, Eq)]
105
125
pub struct Array<'s>(pub Vec<Data<'s>>);
126
+
127
+
impl IntoStatic for Array<'_> {
128
+
type Output = Array<'static>;
129
+
fn into_static(self) -> Array<'static> {
130
+
Array(self.0.into_static())
131
+
}
132
+
}
106
133
107
134
impl<'s> Array<'s> {
108
135
pub fn from_json(json: &'s Vec<serde_json::Value>) -> Result<Self, AtDataError> {
···
123
150
124
151
#[derive(Debug, Clone, PartialEq, Eq)]
125
152
pub struct Object<'s>(pub BTreeMap<SmolStr, Data<'s>>);
153
+
154
+
impl IntoStatic for Object<'_> {
155
+
type Output = Object<'static>;
156
+
fn into_static(self) -> Object<'static> {
157
+
Object(self.0.into_static())
158
+
}
159
+
}
126
160
127
161
impl<'s> Object<'s> {
128
162
pub fn from_json(
+16
-6
crates/jacquard-common/src/types/xrpc.rs
+16
-6
crates/jacquard-common/src/types/xrpc.rs
···
1
+
use serde::de::DeserializeOwned;
1
2
use serde::{Deserialize, Serialize};
2
3
use std::error::Error;
3
4
use std::fmt::{self, Debug};
4
5
6
+
use crate::IntoStatic;
5
7
use crate::types::value::Data;
6
8
7
9
/// XRPC method type
···
47
49
const OUTPUT_ENCODING: &'static str;
48
50
49
51
/// Response output type
50
-
type Output<'de>: Deserialize<'de>;
52
+
type Output<'de>: Deserialize<'de> + IntoStatic;
51
53
52
54
/// Error type for this request
53
-
type Err<'de>: Error;
55
+
type Err<'de>: Error + Deserialize<'de> + IntoStatic;
54
56
}
55
57
56
58
/// Error type for XRPC endpoints that don't define any errors
57
-
#[derive(Debug, Clone, PartialEq, Eq)]
58
-
pub struct GenericError(Data<'static>);
59
+
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
60
+
#[serde(bound(deserialize = "'de: 'a"))]
61
+
pub struct GenericError<'a>(Data<'a>);
59
62
60
-
impl fmt::Display for GenericError {
63
+
impl fmt::Display for GenericError<'_> {
61
64
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
62
65
self.0.fmt(f)
63
66
}
64
67
}
65
68
66
-
impl Error for GenericError {}
69
+
impl Error for GenericError<'_> {}
70
+
71
+
impl IntoStatic for GenericError<'_> {
72
+
type Output = GenericError<'static>;
73
+
fn into_static(self) -> Self::Output {
74
+
GenericError(self.0.into_static())
75
+
}
76
+
}
+3
-3
crates/jacquard-derive/src/lib.rs
+3
-3
crates/jacquard-derive/src/lib.rs
···
103
103
104
104
match &mut input.data {
105
105
Data::Enum(data_enum) => {
106
-
// Check if Other variant already exists
107
-
let has_other = data_enum.variants.iter().any(|v| v.ident == "Other");
106
+
// Check if Unknown variant already exists
107
+
let has_other = data_enum.variants.iter().any(|v| v.ident == "Unknown");
108
108
109
109
if !has_other {
110
110
// Determine the lifetime parameter to use
···
114
114
quote! { 'static }
115
115
};
116
116
117
-
// Add the Other variant
117
+
// Add the Unknown variant
118
118
let new_variant: syn::Variant = syn::parse_quote! {
119
119
#[serde(untagged)]
120
120
Unknown(::jacquard_common::types::value::Data<#lifetime>)
+1
-1
crates/jacquard-lexicon/Cargo.toml
+1
-1
crates/jacquard-lexicon/Cargo.toml
+439
-70
crates/jacquard-lexicon/src/codegen.rs
+439
-70
crates/jacquard-lexicon/src/codegen.rs
···
188
188
}
189
189
};
190
190
191
+
// Generate IntoStatic impl
192
+
let field_names: Vec<&str> = obj.properties.keys().map(|k| k.as_str()).collect();
193
+
let into_static_impl =
194
+
self.generate_into_static_for_struct(&type_name, &field_names, true, true);
195
+
191
196
Ok(quote! {
192
197
#struct_def
193
198
#(#unions)*
194
199
#collection_impl
200
+
#into_static_impl
195
201
})
196
202
}
197
203
}
···
233
239
}
234
240
}
235
241
242
+
// Generate IntoStatic impl
243
+
let field_names: Vec<&str> = obj.properties.keys().map(|k| k.as_str()).collect();
244
+
let into_static_impl =
245
+
self.generate_into_static_for_struct(&type_name, &field_names, true, true);
246
+
236
247
Ok(quote! {
237
248
#struct_def
238
249
#(#unions)*
250
+
#into_static_impl
239
251
})
240
252
}
241
253
···
607
619
let type_base = self.def_to_type_name(nsid, def_name);
608
620
let mut output = Vec::new();
609
621
610
-
let params_has_lifetime = query.parameters.as_ref()
622
+
let params_has_lifetime = query
623
+
.parameters
624
+
.as_ref()
611
625
.map(|p| match p {
612
-
crate::lexicon::LexXrpcQueryParameter::Params(params) => self.params_need_lifetime(params),
626
+
crate::lexicon::LexXrpcQueryParameter::Params(params) => {
627
+
self.params_need_lifetime(params)
628
+
}
613
629
})
614
630
.unwrap_or(false);
615
631
let has_params = query.parameters.is_some();
···
632
648
}
633
649
634
650
// Generate XrpcRequest impl
635
-
let output_encoding = query.output.as_ref()
651
+
let output_encoding = query
652
+
.output
653
+
.as_ref()
636
654
.map(|o| o.encoding.as_ref())
637
655
.unwrap_or("application/json");
638
656
let xrpc_impl = self.generate_xrpc_request_impl(
···
689
707
}
690
708
691
709
// Generate XrpcRequest impl
692
-
let input_encoding = proc.input.as_ref()
710
+
let input_encoding = proc
711
+
.input
712
+
.as_ref()
693
713
.map(|i| i.encoding.as_ref())
694
714
.unwrap_or("application/json");
695
-
let output_encoding = proc.output.as_ref()
715
+
let output_encoding = proc
716
+
.output
717
+
.as_ref()
696
718
.map(|o| o.encoding.as_ref())
697
719
.unwrap_or("application/json");
698
720
let xrpc_impl = self.generate_xrpc_request_impl(
···
790
812
791
813
let doc = self.generate_doc_comment(union.description.as_ref());
792
814
815
+
// Generate IntoStatic impl for the enum
816
+
let variant_info: Vec<(String, EnumVariantKind)> = union
817
+
.refs
818
+
.iter()
819
+
.map(|ref_str| {
820
+
let ref_def = if let Some((_, fragment)) = ref_str.split_once('#') {
821
+
fragment
822
+
} else {
823
+
"main"
824
+
};
825
+
let variant_name = if ref_def == "main" {
826
+
ref_str.split('.').last().unwrap().to_pascal_case()
827
+
} else {
828
+
ref_def.to_pascal_case()
829
+
};
830
+
(variant_name, EnumVariantKind::Tuple)
831
+
})
832
+
.collect();
833
+
let into_static_impl = self.generate_into_static_for_enum(
834
+
&enum_name,
835
+
&variant_info,
836
+
true,
837
+
true, // open union
838
+
);
839
+
793
840
Ok(quote! {
794
841
#doc
795
842
#[jacquard_derive::open_union]
···
799
846
pub enum #enum_ident<'a> {
800
847
#(#variants,)*
801
848
}
849
+
850
+
#into_static_impl
802
851
})
803
852
}
804
853
LexXrpcSubscriptionMessageSchema::Object(obj) => {
···
833
882
unions.push(union_def);
834
883
}
835
884
}
885
+
886
+
// Generate IntoStatic impl
887
+
let field_names: Vec<&str> = obj.properties.keys().map(|k| k.as_str()).collect();
888
+
let into_static_impl =
889
+
self.generate_into_static_for_struct(&struct_name, &field_names, true, true);
836
890
837
891
Ok(quote! {
838
892
#struct_def
839
893
#(#unions)*
894
+
#into_static_impl
840
895
})
841
896
}
842
897
LexXrpcSubscriptionMessageSchema::Ref(ref_type) => {
···
1181
1236
ident: &syn::Ident,
1182
1237
p: &crate::lexicon::LexXrpcParameters<'static>,
1183
1238
) -> Result<TokenStream> {
1184
-
1185
1239
let required = p.required.as_ref().map(|r| r.as_slice()).unwrap_or(&[]);
1186
1240
let mut fields = Vec::new();
1187
-
let mut default_fields = Vec::new();
1241
+
let mut default_fns = Vec::new();
1188
1242
1189
1243
for (field_name, field_type) in &p.properties {
1190
1244
let is_required = required.contains(field_name);
1191
-
let field_tokens =
1192
-
self.generate_param_field("", field_name, field_type, is_required)?;
1245
+
let (field_tokens, default_fn) =
1246
+
self.generate_param_field_with_default("", field_name, field_type, is_required)?;
1193
1247
fields.push(field_tokens);
1194
-
1195
-
// Track field defaults
1196
-
let field_ident = make_ident(&field_name.to_snake_case());
1197
-
let default_value = self.get_param_default_value(field_type, is_required);
1198
-
default_fields.push((field_ident, default_value));
1248
+
if let Some(fn_def) = default_fn {
1249
+
default_fns.push(fn_def);
1250
+
}
1199
1251
}
1200
1252
1201
1253
let doc = self.generate_doc_comment(p.description.as_ref());
1202
1254
let needs_lifetime = self.params_need_lifetime(p);
1203
1255
1204
-
// Check if we should generate Default impl
1205
-
let has_any_defaults = default_fields.iter().any(|(_, default)| default.is_some());
1256
+
let derives =
1257
+
quote! { #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)] };
1206
1258
1207
-
let derives = if has_any_defaults {
1208
-
quote! { #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default)] }
1209
-
} else {
1210
-
quote! { #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)] }
1211
-
};
1212
-
1213
-
let default_impl = if has_any_defaults {
1214
-
let field_inits: Vec<_> = default_fields.iter().map(|(field_ident, default_value)| {
1215
-
if let Some(value) = default_value {
1216
-
quote! { #field_ident: #value }
1217
-
} else {
1218
-
quote! { #field_ident: Default::default() }
1219
-
}
1220
-
}).collect();
1221
-
1222
-
if needs_lifetime {
1223
-
quote! {
1224
-
impl Default for #ident<'_> {
1225
-
fn default() -> Self {
1226
-
Self {
1227
-
#(#field_inits,)*
1228
-
}
1229
-
}
1230
-
}
1231
-
}
1232
-
} else {
1233
-
quote! {} // Default derive handles this
1234
-
}
1235
-
} else {
1236
-
quote! {}
1237
-
};
1259
+
// Generate IntoStatic impl
1260
+
let field_names: Vec<&str> = p.properties.keys().map(|k| k.as_str()).collect();
1261
+
let type_name = ident.to_string();
1262
+
let into_static_impl =
1263
+
self.generate_into_static_for_struct(&type_name, &field_names, needs_lifetime, false);
1238
1264
1239
1265
if needs_lifetime {
1240
1266
Ok(quote! {
1267
+
#(#default_fns)*
1268
+
1241
1269
#doc
1242
1270
#derives
1243
1271
#[serde(rename_all = "camelCase")]
···
1245
1273
#(#fields)*
1246
1274
}
1247
1275
1248
-
#default_impl
1276
+
#into_static_impl
1249
1277
})
1250
1278
} else {
1251
1279
Ok(quote! {
1280
+
#(#default_fns)*
1281
+
1252
1282
#doc
1253
1283
#derives
1254
1284
#[serde(rename_all = "camelCase")]
1255
1285
pub struct #ident {
1256
1286
#(#fields)*
1257
1287
}
1288
+
1289
+
#into_static_impl
1258
1290
})
1259
1291
}
1260
1292
}
1261
1293
1262
-
/// Get default value for a param field
1263
-
fn get_param_default_value(
1294
+
/// Generate param field with serde default if present
1295
+
/// Returns (field_tokens, optional_default_function)
1296
+
fn generate_param_field_with_default(
1264
1297
&self,
1298
+
nsid: &str,
1299
+
field_name: &str,
1265
1300
field_type: &crate::lexicon::LexXrpcParametersProperty<'static>,
1266
1301
is_required: bool,
1267
-
) -> Option<TokenStream> {
1302
+
) -> Result<(TokenStream, Option<TokenStream>)> {
1268
1303
use crate::lexicon::LexXrpcParametersProperty;
1304
+
use heck::ToSnakeCase;
1269
1305
1270
-
let default_opt = match field_type {
1271
-
LexXrpcParametersProperty::Boolean(b) => b.default.map(|v| quote! { #v }),
1272
-
LexXrpcParametersProperty::Integer(i) => i.default.map(|v| quote! { #v }),
1273
-
LexXrpcParametersProperty::String(s) => s.default.as_ref().map(|v| {
1274
-
let s = v.as_ref();
1275
-
quote! { jacquard_common::CowStr::from(#s) }
1276
-
}),
1277
-
LexXrpcParametersProperty::Unknown(_) | LexXrpcParametersProperty::Array(_) => None,
1306
+
// Get base field
1307
+
let base_field = self.generate_param_field(nsid, field_name, field_type, is_required)?;
1308
+
1309
+
// Generate default function and attribute for required fields with defaults
1310
+
// For optional fields, just add doc comments
1311
+
let (doc_comment, serde_attr, default_fn) = if is_required {
1312
+
match field_type {
1313
+
LexXrpcParametersProperty::Boolean(b) if b.default.is_some() => {
1314
+
let v = b.default.unwrap();
1315
+
let fn_name = format!("_default_{}", field_name.to_snake_case());
1316
+
let fn_ident = syn::Ident::new(&fn_name, proc_macro2::Span::call_site());
1317
+
(
1318
+
Some(format!("Defaults to `{}`", v)),
1319
+
Some(quote! { #[serde(default = #fn_name)] }),
1320
+
Some(quote! {
1321
+
fn #fn_ident() -> bool { #v }
1322
+
}),
1323
+
)
1324
+
}
1325
+
LexXrpcParametersProperty::Integer(i) if i.default.is_some() => {
1326
+
let v = i.default.unwrap();
1327
+
let fn_name = format!("_default_{}", field_name.to_snake_case());
1328
+
let fn_ident = syn::Ident::new(&fn_name, proc_macro2::Span::call_site());
1329
+
(
1330
+
Some(format!("Defaults to `{}`", v)),
1331
+
Some(quote! { #[serde(default = #fn_name)] }),
1332
+
Some(quote! {
1333
+
fn #fn_ident() -> i64 { #v }
1334
+
}),
1335
+
)
1336
+
}
1337
+
LexXrpcParametersProperty::String(s) if s.default.is_some() => {
1338
+
let v = s.default.as_ref().unwrap().as_ref();
1339
+
let fn_name = format!("_default_{}", field_name.to_snake_case());
1340
+
let fn_ident = syn::Ident::new(&fn_name, proc_macro2::Span::call_site());
1341
+
(
1342
+
Some(format!("Defaults to `\"{}\"`", v)),
1343
+
Some(quote! { #[serde(default = #fn_name)] }),
1344
+
Some(quote! {
1345
+
fn #fn_ident() -> jacquard_common::CowStr<'static> {
1346
+
jacquard_common::CowStr::from(#v)
1347
+
}
1348
+
}),
1349
+
)
1350
+
}
1351
+
_ => (None, None, None),
1352
+
}
1353
+
} else {
1354
+
// Optional fields - just doc comments, no serde defaults
1355
+
let doc = match field_type {
1356
+
LexXrpcParametersProperty::Integer(i) => {
1357
+
let mut parts = Vec::new();
1358
+
if let Some(def) = i.default {
1359
+
parts.push(format!("default: {}", def));
1360
+
}
1361
+
if let Some(min) = i.minimum {
1362
+
parts.push(format!("min: {}", min));
1363
+
}
1364
+
if let Some(max) = i.maximum {
1365
+
parts.push(format!("max: {}", max));
1366
+
}
1367
+
if !parts.is_empty() {
1368
+
Some(format!("({})", parts.join(", ")))
1369
+
} else {
1370
+
None
1371
+
}
1372
+
}
1373
+
LexXrpcParametersProperty::String(s) => {
1374
+
let mut parts = Vec::new();
1375
+
if let Some(def) = s.default.as_ref() {
1376
+
parts.push(format!("default: \"{}\"", def.as_ref()));
1377
+
}
1378
+
if let Some(min) = s.min_length {
1379
+
parts.push(format!("min length: {}", min));
1380
+
}
1381
+
if let Some(max) = s.max_length {
1382
+
parts.push(format!("max length: {}", max));
1383
+
}
1384
+
if !parts.is_empty() {
1385
+
Some(format!("({})", parts.join(", ")))
1386
+
} else {
1387
+
None
1388
+
}
1389
+
}
1390
+
LexXrpcParametersProperty::Boolean(b) => {
1391
+
b.default.map(|v| format!("(default: {})", v))
1392
+
}
1393
+
_ => None,
1394
+
};
1395
+
(doc, None, None)
1396
+
};
1397
+
1398
+
let doc = doc_comment.as_ref().map(|d| quote! { #[doc = #d] });
1399
+
let field_with_attrs = match (doc, serde_attr) {
1400
+
(Some(doc), Some(attr)) => quote! {
1401
+
#doc
1402
+
#attr
1403
+
#base_field
1404
+
},
1405
+
(Some(doc), None) => quote! {
1406
+
#doc
1407
+
#base_field
1408
+
},
1409
+
(None, Some(attr)) => quote! {
1410
+
#attr
1411
+
#base_field
1412
+
},
1413
+
(None, None) => base_field,
1278
1414
};
1279
1415
1280
-
if is_required {
1281
-
default_opt
1282
-
} else {
1283
-
// Optional fields: wrap in Some() if there's a default, otherwise None
1284
-
default_opt.map(|v| quote! { Some(#v) })
1285
-
}
1416
+
Ok((field_with_attrs, default_fn))
1286
1417
}
1287
1418
1288
1419
/// Generate input struct from XRPC body
···
1318
1449
if let Some(crate::lexicon::LexXrpcBodySchema::Object(obj)) = &body.schema {
1319
1450
for (field_name, field_type) in &obj.properties {
1320
1451
if let LexObjectProperty::Union(union) = field_type {
1321
-
let union_name =
1322
-
format!("{}Record{}", type_base, field_name.to_pascal_case());
1452
+
let union_name = format!("{}Record{}", type_base, field_name.to_pascal_case());
1323
1453
let refs: Vec<_> = union.refs.iter().cloned().collect();
1324
1454
let union_def = self.generate_union(&union_name, &refs, None, union.closed)?;
1325
1455
unions.push(union_def);
···
1327
1457
}
1328
1458
}
1329
1459
1460
+
// Generate IntoStatic impl
1461
+
let field_names: Vec<&str> = match &body.schema {
1462
+
Some(crate::lexicon::LexXrpcBodySchema::Object(obj)) => {
1463
+
obj.properties.keys().map(|k| k.as_str()).collect()
1464
+
}
1465
+
Some(_) => {
1466
+
// For Ref or Union schemas, there's just a single flattened field
1467
+
vec!["value"]
1468
+
}
1469
+
None => {
1470
+
// No schema means no fields, just extra_data
1471
+
vec![]
1472
+
}
1473
+
};
1474
+
let into_static_impl =
1475
+
self.generate_into_static_for_struct(type_base, &field_names, true, true);
1476
+
1330
1477
Ok(quote! {
1331
1478
#struct_def
1332
1479
#(#unions)*
1480
+
#into_static_impl
1333
1481
})
1334
1482
}
1335
1483
···
1376
1524
}
1377
1525
}
1378
1526
1527
+
// Generate IntoStatic impl
1528
+
let field_names: Vec<&str> = match &body.schema {
1529
+
Some(crate::lexicon::LexXrpcBodySchema::Object(obj)) => {
1530
+
obj.properties.keys().map(|k| k.as_str()).collect()
1531
+
}
1532
+
Some(_) => {
1533
+
// For Ref or Union schemas, there's just a single flattened field
1534
+
vec!["value"]
1535
+
}
1536
+
None => {
1537
+
// No schema means no fields, just extra_data
1538
+
vec![]
1539
+
}
1540
+
};
1541
+
let into_static_impl =
1542
+
self.generate_into_static_for_struct(&struct_name, &field_names, true, true);
1543
+
1379
1544
Ok(quote! {
1380
1545
#struct_def
1381
1546
#(#unions)*
1547
+
#into_static_impl
1382
1548
})
1383
1549
}
1384
1550
···
1515
1681
});
1516
1682
}
1517
1683
1684
+
// Generate IntoStatic impl
1685
+
let variant_info: Vec<(String, EnumVariantKind)> = errors
1686
+
.iter()
1687
+
.map(|e| (e.name.to_pascal_case(), EnumVariantKind::Tuple))
1688
+
.collect();
1689
+
let into_static_impl =
1690
+
self.generate_into_static_for_enum(&enum_name, &variant_info, true, true);
1691
+
1518
1692
Ok(quote! {
1519
1693
#[jacquard_derive::open_union]
1520
1694
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, thiserror::Error, miette::Diagnostic)]
···
1532
1706
}
1533
1707
}
1534
1708
}
1709
+
1710
+
#into_static_impl
1535
1711
})
1536
1712
}
1537
1713
···
1571
1747
1572
1748
let doc = self.generate_doc_comment(string.description.as_ref());
1573
1749
1750
+
// Generate IntoStatic impl
1751
+
let variant_info: Vec<(String, EnumVariantKind)> = known_values
1752
+
.iter()
1753
+
.map(|value| {
1754
+
let variant_name = value_to_variant_name(value.as_ref());
1755
+
(variant_name, EnumVariantKind::Unit)
1756
+
})
1757
+
.chain(std::iter::once((
1758
+
"Other".to_string(),
1759
+
EnumVariantKind::Tuple,
1760
+
)))
1761
+
.collect();
1762
+
let into_static_impl =
1763
+
self.generate_into_static_for_enum(&type_name, &variant_info, true, false);
1764
+
1574
1765
Ok(quote! {
1575
1766
#doc
1576
1767
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
···
1633
1824
Ok(Self::from(s))
1634
1825
}
1635
1826
}
1827
+
1828
+
#into_static_impl
1636
1829
})
1637
1830
}
1638
1831
···
1732
1925
has_errors: bool,
1733
1926
) -> Result<TokenStream> {
1734
1927
let output_type = if has_output {
1735
-
let output_ident = syn::Ident::new(&format!("{}Output", type_base), proc_macro2::Span::call_site());
1928
+
let output_ident = syn::Ident::new(
1929
+
&format!("{}Output", type_base),
1930
+
proc_macro2::Span::call_site(),
1931
+
);
1736
1932
quote! { #output_ident<'de> }
1737
1933
} else {
1738
1934
quote! { () }
1739
1935
};
1740
1936
1741
1937
let error_type = if has_errors {
1742
-
let error_ident = syn::Ident::new(&format!("{}Error", type_base), proc_macro2::Span::call_site());
1938
+
let error_ident = syn::Ident::new(
1939
+
&format!("{}Error", type_base),
1940
+
proc_macro2::Span::call_site(),
1941
+
);
1743
1942
quote! { #error_ident<'de> }
1744
1943
} else {
1745
-
quote! { jacquard_common::types::xrpc::GenericError }
1944
+
quote! { jacquard_common::types::xrpc::GenericError<'de> }
1746
1945
};
1747
1946
1748
1947
if has_params {
···
1839
2038
// Only add open_union if not closed
1840
2039
let is_open = closed != Some(true);
1841
2040
2041
+
// Generate IntoStatic impl
2042
+
let variant_info: Vec<(String, EnumVariantKind)> = refs
2043
+
.iter()
2044
+
.filter_map(|ref_str| {
2045
+
// Skip unknown refs
2046
+
if !self.corpus.ref_exists(ref_str.as_ref()) {
2047
+
return None;
2048
+
}
2049
+
2050
+
let (ref_nsid, ref_def) = if let Some((nsid, fragment)) = ref_str.split_once('#') {
2051
+
(nsid, fragment)
2052
+
} else {
2053
+
(ref_str.as_ref(), "main")
2054
+
};
2055
+
2056
+
let variant_name = if ref_def == "main" {
2057
+
ref_nsid.split('.').last().unwrap().to_pascal_case()
2058
+
} else {
2059
+
let last_segment = ref_nsid.split('.').last().unwrap().to_pascal_case();
2060
+
format!("{}{}", last_segment, ref_def.to_pascal_case())
2061
+
};
2062
+
Some((variant_name, EnumVariantKind::Tuple))
2063
+
})
2064
+
.collect();
2065
+
let into_static_impl =
2066
+
self.generate_into_static_for_enum(union_name, &variant_info, true, is_open);
2067
+
1842
2068
if is_open {
1843
2069
Ok(quote! {
1844
2070
#doc
···
1849
2075
pub enum #enum_ident<'a> {
1850
2076
#(#variants,)*
1851
2077
}
2078
+
2079
+
#into_static_impl
1852
2080
})
1853
2081
} else {
1854
2082
Ok(quote! {
···
1859
2087
pub enum #enum_ident<'a> {
1860
2088
#(#variants,)*
1861
2089
}
2090
+
2091
+
#into_static_impl
1862
2092
})
1863
2093
}
1864
2094
}
2095
+
2096
+
/// Generate IntoStatic impl for a struct
2097
+
fn generate_into_static_for_struct(
2098
+
&self,
2099
+
type_name: &str,
2100
+
field_names: &[&str],
2101
+
has_lifetime: bool,
2102
+
has_extra_data: bool,
2103
+
) -> TokenStream {
2104
+
let ident = syn::Ident::new(type_name, proc_macro2::Span::call_site());
2105
+
2106
+
let field_idents: Vec<_> = field_names
2107
+
.iter()
2108
+
.map(|name| make_ident(&name.to_snake_case()))
2109
+
.collect();
2110
+
2111
+
if has_lifetime {
2112
+
let field_conversions: Vec<_> = field_idents
2113
+
.iter()
2114
+
.map(|field| quote! { #field: self.#field.into_static() })
2115
+
.collect();
2116
+
2117
+
let extra_data_conversion = if has_extra_data {
2118
+
quote! { extra_data: self.extra_data.into_static(), }
2119
+
} else {
2120
+
quote! {}
2121
+
};
2122
+
2123
+
quote! {
2124
+
impl jacquard_common::IntoStatic for #ident<'_> {
2125
+
type Output = #ident<'static>;
2126
+
2127
+
fn into_static(self) -> Self::Output {
2128
+
#ident {
2129
+
#(#field_conversions,)*
2130
+
#extra_data_conversion
2131
+
}
2132
+
}
2133
+
}
2134
+
}
2135
+
} else {
2136
+
quote! {
2137
+
impl jacquard_common::IntoStatic for #ident {
2138
+
type Output = #ident;
2139
+
2140
+
fn into_static(self) -> Self::Output {
2141
+
self
2142
+
}
2143
+
}
2144
+
}
2145
+
}
2146
+
}
2147
+
2148
+
/// Generate IntoStatic impl for an enum
2149
+
fn generate_into_static_for_enum(
2150
+
&self,
2151
+
type_name: &str,
2152
+
variant_info: &[(String, EnumVariantKind)],
2153
+
has_lifetime: bool,
2154
+
is_open: bool,
2155
+
) -> TokenStream {
2156
+
let ident = syn::Ident::new(type_name, proc_macro2::Span::call_site());
2157
+
2158
+
if has_lifetime {
2159
+
let variant_conversions: Vec<_> = variant_info
2160
+
.iter()
2161
+
.map(|(variant_name, kind)| {
2162
+
let variant_ident = syn::Ident::new(variant_name, proc_macro2::Span::call_site());
2163
+
match kind {
2164
+
EnumVariantKind::Unit => {
2165
+
quote! {
2166
+
#ident::#variant_ident => #ident::#variant_ident
2167
+
}
2168
+
}
2169
+
EnumVariantKind::Tuple => {
2170
+
quote! {
2171
+
#ident::#variant_ident(v) => #ident::#variant_ident(v.into_static())
2172
+
}
2173
+
}
2174
+
EnumVariantKind::Struct(fields) => {
2175
+
let field_idents: Vec<_> = fields
2176
+
.iter()
2177
+
.map(|f| make_ident(&f.to_snake_case()))
2178
+
.collect();
2179
+
let field_conversions: Vec<_> = field_idents
2180
+
.iter()
2181
+
.map(|f| quote! { #f: #f.into_static() })
2182
+
.collect();
2183
+
quote! {
2184
+
#ident::#variant_ident { #(#field_idents,)* } => #ident::#variant_ident {
2185
+
#(#field_conversions,)*
2186
+
}
2187
+
}
2188
+
}
2189
+
}
2190
+
})
2191
+
.collect();
2192
+
2193
+
let unknown_conversion = if is_open {
2194
+
quote! {
2195
+
#ident::Unknown(v) => #ident::Unknown(v.into_static()),
2196
+
}
2197
+
} else {
2198
+
quote! {}
2199
+
};
2200
+
2201
+
quote! {
2202
+
impl jacquard_common::IntoStatic for #ident<'_> {
2203
+
type Output = #ident<'static>;
2204
+
2205
+
fn into_static(self) -> Self::Output {
2206
+
match self {
2207
+
#(#variant_conversions,)*
2208
+
#unknown_conversion
2209
+
}
2210
+
}
2211
+
}
2212
+
}
2213
+
} else {
2214
+
quote! {
2215
+
impl jacquard_common::IntoStatic for #ident {
2216
+
type Output = #ident;
2217
+
2218
+
fn into_static(self) -> Self::Output {
2219
+
self
2220
+
}
2221
+
}
2222
+
}
2223
+
}
2224
+
}
2225
+
}
2226
+
2227
+
/// Enum variant kind for IntoStatic generation
2228
+
#[derive(Debug, Clone)]
2229
+
#[allow(dead_code)]
2230
+
enum EnumVariantKind {
2231
+
Unit,
2232
+
Tuple,
2233
+
Struct(Vec<String>),
1865
2234
}
1866
2235
1867
2236
#[cfg(test)]
+16
crates/jacquard/Cargo.toml
+16
crates/jacquard/Cargo.toml
···
8
8
9
9
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
10
10
11
+
[lib]
12
+
name = "jacquard"
13
+
path = "src/lib.rs"
14
+
15
+
[[bin]]
16
+
name = "jacquard"
17
+
path = "src/main.rs"
18
+
11
19
[dependencies]
20
+
bytes = "1.10"
12
21
clap = { workspace = true }
22
+
http = "1.3.1"
13
23
jacquard-api = { version = "0.1.0", path = "../jacquard-api" }
14
24
jacquard-common = { path = "../jacquard-common" }
25
+
miette = "7.6.0"
15
26
reqwest = { version = "0.12.23", default-features = false, features = ["charset", "http2", "json", "system-proxy", "gzip", "rustls-tls"] }
27
+
serde = { version = "1.0", features = ["derive"] }
28
+
serde_html_form = "0.2"
29
+
serde_ipld_dagcbor = "0.6.4"
30
+
serde_json = "1.0"
31
+
thiserror = "2.0"
+171
crates/jacquard/src/client.rs
+171
crates/jacquard/src/client.rs
···
1
+
mod error;
2
+
mod response;
3
+
4
+
use std::fmt::Display;
5
+
use std::future::Future;
6
+
7
+
pub use error::{ClientError, Result};
8
+
use bytes::Bytes;
9
+
use http::{
10
+
HeaderName, HeaderValue, Request,
11
+
header::{AUTHORIZATION, CONTENT_TYPE, InvalidHeaderValue},
12
+
};
13
+
pub use response::Response;
14
+
use serde::Serialize;
15
+
16
+
use jacquard_common::{CowStr, types::xrpc::{XrpcMethod, XrpcRequest}};
17
+
18
+
pub trait HttpClient {
19
+
type Error: std::error::Error + Display + Send + Sync + 'static;
20
+
/// Send an HTTP request and return the response.
21
+
fn send_http(
22
+
&self,
23
+
request: Request<Vec<u8>>,
24
+
) -> impl Future<Output = core::result::Result<http::Response<Vec<u8>>, Self::Error>>;
25
+
}
26
+
/// XRPC client trait
27
+
pub trait XrpcClient: HttpClient {
28
+
fn base_uri(&self) -> CowStr<'_>;
29
+
#[allow(unused_variables)]
30
+
fn authorization_token(
31
+
&self,
32
+
is_refresh: bool,
33
+
) -> impl Future<Output = Option<AuthorizationToken<'_>>> {
34
+
async { None }
35
+
}
36
+
/// Get the `atproto-proxy` header.
37
+
fn atproto_proxy_header(&self) -> impl Future<Output = Option<String>> {
38
+
async { None }
39
+
}
40
+
/// Get the `atproto-accept-labelers` header.
41
+
fn atproto_accept_labelers_header(&self) -> impl Future<Output = Option<Vec<String>>> {
42
+
async { None }
43
+
}
44
+
/// Send an XRPC request and get back a response
45
+
fn send<R: XrpcRequest>(&self, request: R) -> impl Future<Output = Result<Response<R>>>
46
+
where
47
+
Self: Sized,
48
+
{
49
+
send_xrpc(self, request)
50
+
}
51
+
}
52
+
53
+
pub(crate) const NSID_REFRESH_SESSION: &str = "com.atproto.server.refreshSession";
54
+
55
+
pub enum AuthorizationToken<'s> {
56
+
Bearer(CowStr<'s>),
57
+
Dpop(CowStr<'s>),
58
+
}
59
+
60
+
impl TryFrom<AuthorizationToken<'_>> for HeaderValue {
61
+
type Error = InvalidHeaderValue;
62
+
63
+
fn try_from(token: AuthorizationToken) -> core::result::Result<Self, Self::Error> {
64
+
HeaderValue::from_str(&match token {
65
+
AuthorizationToken::Bearer(t) => format!("Bearer {t}"),
66
+
AuthorizationToken::Dpop(t) => format!("DPoP {t}"),
67
+
})
68
+
}
69
+
}
70
+
71
+
/// HTTP headers which can be used in XPRC requests.
72
+
pub enum Header {
73
+
ContentType,
74
+
Authorization,
75
+
AtprotoProxy,
76
+
AtprotoAcceptLabelers,
77
+
}
78
+
79
+
impl From<Header> for HeaderName {
80
+
fn from(value: Header) -> Self {
81
+
match value {
82
+
Header::ContentType => CONTENT_TYPE,
83
+
Header::Authorization => AUTHORIZATION,
84
+
Header::AtprotoProxy => HeaderName::from_static("atproto-proxy"),
85
+
Header::AtprotoAcceptLabelers => HeaderName::from_static("atproto-accept-labelers"),
86
+
}
87
+
}
88
+
}
89
+
90
+
/// Generic XRPC send implementation that uses HttpClient
91
+
async fn send_xrpc<R, C>(client: &C, request: R) -> Result<Response<R>>
92
+
where
93
+
R: XrpcRequest,
94
+
C: XrpcClient + ?Sized,
95
+
{
96
+
// Build URI: base_uri + /xrpc/ + NSID
97
+
let mut uri = format!("{}/xrpc/{}", client.base_uri(), R::NSID);
98
+
99
+
// Add query parameters for Query methods
100
+
if let XrpcMethod::Query = R::METHOD {
101
+
if let Ok(qs) = serde_html_form::to_string(&request) {
102
+
if !qs.is_empty() {
103
+
uri.push('?');
104
+
uri.push_str(&qs);
105
+
}
106
+
}
107
+
}
108
+
109
+
// Build HTTP request
110
+
let method = match R::METHOD {
111
+
XrpcMethod::Query => http::Method::GET,
112
+
XrpcMethod::Procedure(_) => http::Method::POST,
113
+
};
114
+
115
+
let mut builder = Request::builder().method(method).uri(&uri);
116
+
117
+
// Add Content-Type for procedures
118
+
if let XrpcMethod::Procedure(encoding) = R::METHOD {
119
+
builder = builder.header(Header::ContentType, encoding);
120
+
}
121
+
122
+
// Add authorization header
123
+
let is_refresh = R::NSID == NSID_REFRESH_SESSION;
124
+
if let Some(token) = client.authorization_token(is_refresh).await {
125
+
let header_value: HeaderValue = token.try_into().map_err(|e| {
126
+
error::TransportError::InvalidRequest(format!("Invalid authorization token: {}", e))
127
+
})?;
128
+
builder = builder.header(Header::Authorization, header_value);
129
+
}
130
+
131
+
// Add atproto-proxy header
132
+
if let Some(proxy) = client.atproto_proxy_header().await {
133
+
builder = builder.header(Header::AtprotoProxy, proxy);
134
+
}
135
+
136
+
// Add atproto-accept-labelers header
137
+
if let Some(labelers) = client.atproto_accept_labelers_header().await {
138
+
builder = builder.header(Header::AtprotoAcceptLabelers, labelers.join(", "));
139
+
}
140
+
141
+
// Serialize body for procedures
142
+
let body = if let XrpcMethod::Procedure(encoding) = R::METHOD {
143
+
if encoding == "application/json" {
144
+
serde_json::to_vec(&request).map_err(error::EncodeError::Json)?
145
+
} else {
146
+
// For other encodings, we'd need different serialization
147
+
vec![]
148
+
}
149
+
} else {
150
+
vec![]
151
+
};
152
+
153
+
let http_request = builder.body(body).expect("Failed to build HTTP request");
154
+
155
+
// Send HTTP request
156
+
let http_response = client.send_http(http_request).await.map_err(|e| {
157
+
error::TransportError::Other(Box::new(e))
158
+
})?;
159
+
160
+
// Check status
161
+
if !http_response.status().is_success() {
162
+
return Err(ClientError::Http(error::HttpError {
163
+
status: http_response.status(),
164
+
body: Some(Bytes::from(http_response.body().clone())),
165
+
}));
166
+
}
167
+
168
+
// Convert to Response
169
+
let buffer = Bytes::from(http_response.into_body());
170
+
Ok(Response::new(buffer))
171
+
}
+149
crates/jacquard/src/client/error.rs
+149
crates/jacquard/src/client/error.rs
···
1
+
use bytes::Bytes;
2
+
3
+
/// Client error type
4
+
#[derive(Debug, thiserror::Error, miette::Diagnostic)]
5
+
pub enum ClientError {
6
+
/// HTTP transport error
7
+
#[error("HTTP transport error: {0}")]
8
+
Transport(
9
+
#[from]
10
+
#[diagnostic_source]
11
+
TransportError,
12
+
),
13
+
14
+
/// Request serialization failed
15
+
#[error("{0}")]
16
+
Encode(
17
+
#[from]
18
+
#[diagnostic_source]
19
+
EncodeError,
20
+
),
21
+
22
+
/// Response deserialization failed
23
+
#[error("{0}")]
24
+
Decode(
25
+
#[from]
26
+
#[diagnostic_source]
27
+
DecodeError,
28
+
),
29
+
30
+
/// HTTP error response
31
+
#[error("HTTP {0}")]
32
+
Http(
33
+
#[from]
34
+
#[diagnostic_source]
35
+
HttpError,
36
+
),
37
+
38
+
/// Authentication error
39
+
#[error("Authentication error: {0}")]
40
+
Auth(
41
+
#[from]
42
+
#[diagnostic_source]
43
+
AuthError,
44
+
),
45
+
}
46
+
47
+
#[derive(Debug, thiserror::Error, miette::Diagnostic)]
48
+
pub enum TransportError {
49
+
#[error("Connection error: {0}")]
50
+
Connect(String),
51
+
52
+
#[error("Request timeout")]
53
+
Timeout,
54
+
55
+
#[error("Invalid request: {0}")]
56
+
InvalidRequest(String),
57
+
58
+
#[error("Transport error: {0}")]
59
+
Other(Box<dyn std::error::Error + Send + Sync>),
60
+
}
61
+
62
+
#[derive(Debug, thiserror::Error, miette::Diagnostic)]
63
+
pub enum EncodeError {
64
+
#[error("Failed to serialize query: {0}")]
65
+
Query(
66
+
#[from]
67
+
#[source]
68
+
serde_html_form::ser::Error,
69
+
),
70
+
#[error("Failed to serialize JSON: {0}")]
71
+
Json(
72
+
#[from]
73
+
#[source]
74
+
serde_json::Error,
75
+
),
76
+
}
77
+
78
+
#[derive(Debug, thiserror::Error, miette::Diagnostic)]
79
+
pub enum DecodeError {
80
+
#[error("Failed to deserialize JSON: {0}")]
81
+
Json(
82
+
#[from]
83
+
#[source]
84
+
serde_json::Error,
85
+
),
86
+
#[error("Failed to deserialize CBOR: {0}")]
87
+
CborLocal(
88
+
#[from]
89
+
#[source]
90
+
serde_ipld_dagcbor::DecodeError<std::io::Error>,
91
+
),
92
+
#[error("Failed to deserialize CBOR: {0}")]
93
+
CborRemote(
94
+
#[from]
95
+
#[source]
96
+
serde_ipld_dagcbor::DecodeError<reqwest::Error>,
97
+
),
98
+
}
99
+
100
+
#[derive(Debug, thiserror::Error, miette::Diagnostic)]
101
+
pub struct HttpError {
102
+
pub status: http::StatusCode,
103
+
pub body: Option<Bytes>,
104
+
}
105
+
106
+
impl std::fmt::Display for HttpError {
107
+
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
108
+
write!(f, "HTTP {}", self.status)?;
109
+
if let Some(body) = &self.body {
110
+
if let Ok(s) = std::str::from_utf8(body) {
111
+
write!(f, ":\n{}", s)?;
112
+
}
113
+
}
114
+
Ok(())
115
+
}
116
+
}
117
+
118
+
#[derive(Debug, thiserror::Error, miette::Diagnostic)]
119
+
pub enum AuthError {
120
+
#[error("Access token expired")]
121
+
TokenExpired,
122
+
123
+
#[error("Invalid access token")]
124
+
InvalidToken,
125
+
126
+
#[error("Token refresh failed")]
127
+
RefreshFailed,
128
+
129
+
#[error("No authentication provided")]
130
+
NotAuthenticated,
131
+
#[error("Authentication error: {0:?}")]
132
+
Other(http::HeaderValue),
133
+
}
134
+
135
+
pub type Result<T> = std::result::Result<T, ClientError>;
136
+
137
+
impl From<reqwest::Error> for TransportError {
138
+
fn from(e: reqwest::Error) -> Self {
139
+
if e.is_timeout() {
140
+
Self::Timeout
141
+
} else if e.is_connect() {
142
+
Self::Connect(e.to_string())
143
+
} else if e.is_builder() || e.is_request() {
144
+
Self::InvalidRequest(e.to_string())
145
+
} else {
146
+
Self::Other(Box::new(e))
147
+
}
148
+
}
149
+
}
+93
crates/jacquard/src/client/response.rs
+93
crates/jacquard/src/client/response.rs
···
1
+
use bytes::Bytes;
2
+
use jacquard_common::IntoStatic;
3
+
use jacquard_common::types::xrpc::XrpcRequest;
4
+
use std::marker::PhantomData;
5
+
6
+
/// XRPC response wrapper that owns the response buffer
7
+
///
8
+
/// Allows borrowing from the buffer when parsing to avoid unnecessary allocations.
9
+
pub struct Response<R: XrpcRequest> {
10
+
buffer: Bytes,
11
+
_marker: PhantomData<R>,
12
+
}
13
+
14
+
impl<R: XrpcRequest> Response<R> {
15
+
/// Create a new response from a buffer
16
+
pub fn new(buffer: Bytes) -> Self {
17
+
Self {
18
+
buffer,
19
+
_marker: PhantomData,
20
+
}
21
+
}
22
+
23
+
/// Parse the response, borrowing from the internal buffer
24
+
pub fn parse(&self) -> Result<R::Output<'_>, XrpcError<R::Err<'_>>> {
25
+
// Use a helper to make lifetime inference work
26
+
fn parse_output<'b, R: XrpcRequest>(
27
+
buffer: &'b [u8],
28
+
) -> Result<R::Output<'b>, serde_json::Error> {
29
+
serde_json::from_slice(buffer)
30
+
}
31
+
32
+
fn parse_error<'b, R: XrpcRequest>(
33
+
buffer: &'b [u8],
34
+
) -> Result<R::Err<'b>, serde_json::Error> {
35
+
serde_json::from_slice(buffer)
36
+
}
37
+
38
+
let output = parse_output::<R>(&self.buffer);
39
+
if let Ok(output) = output {
40
+
Ok(output)
41
+
} else {
42
+
// Try to parse as error
43
+
match parse_error::<R>(&self.buffer) {
44
+
Ok(error) => Err(XrpcError::Xrpc(error)),
45
+
Err(e) => Err(XrpcError::Decode(e)),
46
+
}
47
+
}
48
+
}
49
+
50
+
/// Parse the response into an owned output
51
+
pub fn into_output(self) -> Result<R::Output<'static>, XrpcError<R::Err<'static>>>
52
+
where
53
+
for<'a> R::Output<'a>: IntoStatic<Output = R::Output<'static>>,
54
+
for<'a> R::Err<'a>: IntoStatic<Output = R::Err<'static>>,
55
+
{
56
+
// Use a helper to make lifetime inference work
57
+
fn parse_output<'b, R: XrpcRequest>(
58
+
buffer: &'b [u8],
59
+
) -> Result<R::Output<'b>, serde_json::Error> {
60
+
serde_json::from_slice(buffer)
61
+
}
62
+
63
+
fn parse_error<'b, R: XrpcRequest>(
64
+
buffer: &'b [u8],
65
+
) -> Result<R::Err<'b>, serde_json::Error> {
66
+
serde_json::from_slice(buffer)
67
+
}
68
+
69
+
let output = parse_output::<R>(&self.buffer);
70
+
if let Ok(output) = output {
71
+
Ok(output.into_static())
72
+
} else {
73
+
// Try to parse as error
74
+
match parse_error::<R>(&self.buffer) {
75
+
Ok(error) => Err(XrpcError::Xrpc(error.into_static())),
76
+
Err(e) => Err(XrpcError::Decode(e)),
77
+
}
78
+
}
79
+
}
80
+
81
+
/// Get the raw buffer
82
+
pub fn buffer(&self) -> &Bytes {
83
+
&self.buffer
84
+
}
85
+
}
86
+
87
+
#[derive(Debug, thiserror::Error, miette::Diagnostic)]
88
+
pub enum XrpcError<E: std::error::Error + IntoStatic> {
89
+
#[error("XRPC error: {0}")]
90
+
Xrpc(E),
91
+
#[error("Failed to decode response: {0}")]
92
+
Decode(#[from] serde_json::Error),
93
+
}