1use super::types::*;
4use crate::invoke::{Error, InvokeOptions, Invoker, Result};
5
6pub struct DocApi<'a, I: Invoker> {
7 invoker: &'a I,
8}
9impl<'a, I: Invoker> DocApi<'a, I> {
10 pub fn new(invoker: &'a I) -> Self {
11 Self { invoker }
12 }
13 pub fn authorities(&self) -> DocApiAuthorities<'a, I> {
14 DocApiAuthorities::new(self.invoker)
15 }
16 pub fn blocks(&self) -> DocApiBlocks<'a, I> {
17 DocApiBlocks::new(self.invoker)
18 }
19 pub fn bookmarks(&self) -> DocApiBookmarks<'a, I> {
20 DocApiBookmarks::new(self.invoker)
21 }
22 pub fn capabilities(&self) -> DocApiCapabilities<'a, I> {
23 DocApiCapabilities::new(self.invoker)
24 }
25 pub fn captions(&self) -> DocApiCaptions<'a, I> {
26 DocApiCaptions::new(self.invoker)
27 }
28 pub fn citations(&self) -> DocApiCitations<'a, I> {
29 DocApiCitations::new(self.invoker)
30 }
31 pub fn clipboard(&self) -> DocApiClipboard<'a, I> {
32 DocApiClipboard::new(self.invoker)
33 }
34 pub fn comments(&self) -> DocApiComments<'a, I> {
35 DocApiComments::new(self.invoker)
36 }
37 pub fn content_controls(&self) -> DocApiContentControls<'a, I> {
38 DocApiContentControls::new(self.invoker)
39 }
40 pub fn create(&self) -> DocApiCreate<'a, I> {
41 DocApiCreate::new(self.invoker)
42 }
43 pub fn cross_refs(&self) -> DocApiCrossRefs<'a, I> {
44 DocApiCrossRefs::new(self.invoker)
45 }
46 pub fn custom_xml(&self) -> DocApiCustomXml<'a, I> {
47 DocApiCustomXml::new(self.invoker)
48 }
49 pub fn diff(&self) -> DocApiDiff<'a, I> {
50 DocApiDiff::new(self.invoker)
51 }
52 pub fn export(&self) -> DocApiExport<'a, I> {
53 DocApiExport::new(self.invoker)
54 }
55 pub fn fields(&self) -> DocApiFields<'a, I> {
56 DocApiFields::new(self.invoker)
57 }
58 pub fn footnotes(&self) -> DocApiFootnotes<'a, I> {
59 DocApiFootnotes::new(self.invoker)
60 }
61 pub fn format(&self) -> DocApiFormat<'a, I> {
62 DocApiFormat::new(self.invoker)
63 }
64 pub fn header_footers(&self) -> DocApiHeaderFooters<'a, I> {
65 DocApiHeaderFooters::new(self.invoker)
66 }
67 pub fn history(&self) -> DocApiHistory<'a, I> {
68 DocApiHistory::new(self.invoker)
69 }
70 pub fn hyperlinks(&self) -> DocApiHyperlinks<'a, I> {
71 DocApiHyperlinks::new(self.invoker)
72 }
73 pub fn images(&self) -> DocApiImages<'a, I> {
74 DocApiImages::new(self.invoker)
75 }
76 pub fn index(&self) -> DocApiIndex<'a, I> {
77 DocApiIndex::new(self.invoker)
78 }
79 pub fn lists(&self) -> DocApiLists<'a, I> {
80 DocApiLists::new(self.invoker)
81 }
82 pub fn metadata(&self) -> DocApiMetadata<'a, I> {
83 DocApiMetadata::new(self.invoker)
84 }
85 pub fn mutations(&self) -> DocApiMutations<'a, I> {
86 DocApiMutations::new(self.invoker)
87 }
88 pub fn permission_ranges(&self) -> DocApiPermissionRanges<'a, I> {
89 DocApiPermissionRanges::new(self.invoker)
90 }
91 pub fn plan(&self) -> DocApiPlan<'a, I> {
92 DocApiPlan::new(self.invoker)
93 }
94 pub fn preset(&self) -> DocApiPreset<'a, I> {
95 DocApiPreset::new(self.invoker)
96 }
97 pub fn protection(&self) -> DocApiProtection<'a, I> {
98 DocApiProtection::new(self.invoker)
99 }
100 pub fn query(&self) -> DocApiQuery<'a, I> {
101 DocApiQuery::new(self.invoker)
102 }
103 pub fn ranges(&self) -> DocApiRanges<'a, I> {
104 DocApiRanges::new(self.invoker)
105 }
106 pub fn sections(&self) -> DocApiSections<'a, I> {
107 DocApiSections::new(self.invoker)
108 }
109 pub fn selection(&self) -> DocApiSelection<'a, I> {
110 DocApiSelection::new(self.invoker)
111 }
112 pub fn styles(&self) -> DocApiStyles<'a, I> {
113 DocApiStyles::new(self.invoker)
114 }
115 pub fn tables(&self) -> DocApiTables<'a, I> {
116 DocApiTables::new(self.invoker)
117 }
118 pub fn templates(&self) -> DocApiTemplates<'a, I> {
119 DocApiTemplates::new(self.invoker)
120 }
121 pub fn toc(&self) -> DocApiToc<'a, I> {
122 DocApiToc::new(self.invoker)
123 }
124 pub fn track_changes(&self) -> DocApiTrackChanges<'a, I> {
125 DocApiTrackChanges::new(self.invoker)
126 }
127 pub fn watermarks(&self) -> DocApiWatermarks<'a, I> {
128 DocApiWatermarks::new(self.invoker)
129 }
130
131 pub async fn clear_content(
132 &self,
133 params: &DocClearContentBoundParams,
134 ) -> Result<DocClearContentResult> {
135 self.clear_content_with_options(params, InvokeOptions::default())
136 .await
137 }
138 pub async fn clear_content_with_options(
139 &self,
140 params: &DocClearContentBoundParams,
141 options: InvokeOptions,
142 ) -> Result<DocClearContentResult> {
143 let params = serde_json::to_value(params)
144 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
145 let result = self
146 .invoker
147 .invoke("doc.clearContent", params, options)
148 .await?;
149 serde_json::from_value(result).map_err(|decode| {
150 let mut error = Error::decode(decode);
151 error.operation_id = Some("doc.clearContent".to_owned());
152 error.outcome_unknown = true;
153 error
154 })
155 }
156
157 pub async fn close(&self, params: &DocCloseBoundParams) -> Result<DocCloseResult> {
158 self.close_with_options(params, InvokeOptions::default())
159 .await
160 }
161 pub async fn close_with_options(
162 &self,
163 params: &DocCloseBoundParams,
164 options: InvokeOptions,
165 ) -> Result<DocCloseResult> {
166 let params = serde_json::to_value(params)
167 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
168 let result = self.invoker.invoke("doc.close", params, options).await?;
169 serde_json::from_value(result).map_err(|decode| {
170 let mut error = Error::decode(decode);
171 error.operation_id = Some("doc.close".to_owned());
172 error.outcome_unknown = true;
173 error
174 })
175 }
176
177 pub async fn delete(&self, params: &DocDeleteBoundParams) -> Result<DocDeleteResult> {
178 self.delete_with_options(params, InvokeOptions::default())
179 .await
180 }
181 pub async fn delete_with_options(
182 &self,
183 params: &DocDeleteBoundParams,
184 options: InvokeOptions,
185 ) -> Result<DocDeleteResult> {
186 let params = serde_json::to_value(params)
187 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
188 let result = self.invoker.invoke("doc.delete", params, options).await?;
189 serde_json::from_value(result).map_err(|decode| {
190 let mut error = Error::decode(decode);
191 error.operation_id = Some("doc.delete".to_owned());
192 error.outcome_unknown = true;
193 error
194 })
195 }
196
197 pub async fn execute_code(
198 &self,
199 params: &DocExecuteCodeBoundParams,
200 ) -> Result<DocExecuteCodeResult> {
201 self.execute_code_with_options(params, InvokeOptions::default())
202 .await
203 }
204 pub async fn execute_code_with_options(
205 &self,
206 params: &DocExecuteCodeBoundParams,
207 options: InvokeOptions,
208 ) -> Result<DocExecuteCodeResult> {
209 let params = serde_json::to_value(params)
210 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
211 let result = self
212 .invoker
213 .invoke("doc.executeCode", params, options)
214 .await?;
215 serde_json::from_value(result).map_err(|decode| {
216 let mut error = Error::decode(decode);
217 error.operation_id = Some("doc.executeCode".to_owned());
218 error.outcome_unknown = true;
219 error
220 })
221 }
222
223 pub async fn extract(&self, params: &DocExtractBoundParams) -> Result<DocExtractResult> {
224 self.extract_with_options(params, InvokeOptions::default())
225 .await
226 }
227 pub async fn extract_with_options(
228 &self,
229 params: &DocExtractBoundParams,
230 options: InvokeOptions,
231 ) -> Result<DocExtractResult> {
232 let params = serde_json::to_value(params)
233 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
234 let result = self.invoker.invoke("doc.extract", params, options).await?;
235 serde_json::from_value(result).map_err(|decode| {
236 let mut error = Error::decode(decode);
237 error.operation_id = Some("doc.extract".to_owned());
238 error.outcome_unknown = false;
239 error
240 })
241 }
242
243 pub async fn find(&self, params: &DocFindBoundParams) -> Result<DocFindResult> {
244 self.find_with_options(params, InvokeOptions::default())
245 .await
246 }
247 pub async fn find_with_options(
248 &self,
249 params: &DocFindBoundParams,
250 options: InvokeOptions,
251 ) -> Result<DocFindResult> {
252 let params = serde_json::to_value(params)
253 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
254 let result = self.invoker.invoke("doc.find", params, options).await?;
255 serde_json::from_value(result).map_err(|decode| {
256 let mut error = Error::decode(decode);
257 error.operation_id = Some("doc.find".to_owned());
258 error.outcome_unknown = false;
259 error
260 })
261 }
262
263 pub async fn format_range(
264 &self,
265 params: &DocFormatRangeBoundParams,
266 ) -> Result<DocFormatRangeResult> {
267 self.format_range_with_options(params, InvokeOptions::default())
268 .await
269 }
270 pub async fn format_range_with_options(
271 &self,
272 params: &DocFormatRangeBoundParams,
273 options: InvokeOptions,
274 ) -> Result<DocFormatRangeResult> {
275 let params = serde_json::to_value(params)
276 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
277 let result = self
278 .invoker
279 .invoke("doc.formatRange", params, options)
280 .await?;
281 serde_json::from_value(result).map_err(|decode| {
282 let mut error = Error::decode(decode);
283 error.operation_id = Some("doc.formatRange".to_owned());
284 error.outcome_unknown = true;
285 error
286 })
287 }
288
289 pub async fn get(&self, params: &DocGetBoundParams) -> Result<DocGetResult> {
290 self.get_with_options(params, InvokeOptions::default())
291 .await
292 }
293 pub async fn get_with_options(
294 &self,
295 params: &DocGetBoundParams,
296 options: InvokeOptions,
297 ) -> Result<DocGetResult> {
298 let params = serde_json::to_value(params)
299 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
300 let result = self.invoker.invoke("doc.get", params, options).await?;
301 serde_json::from_value(result).map_err(|decode| {
302 let mut error = Error::decode(decode);
303 error.operation_id = Some("doc.get".to_owned());
304 error.outcome_unknown = false;
305 error
306 })
307 }
308
309 pub async fn get_html(&self, params: &DocGetHtmlBoundParams) -> Result<DocGetHtmlResult> {
310 self.get_html_with_options(params, InvokeOptions::default())
311 .await
312 }
313 pub async fn get_html_with_options(
314 &self,
315 params: &DocGetHtmlBoundParams,
316 options: InvokeOptions,
317 ) -> Result<DocGetHtmlResult> {
318 let params = serde_json::to_value(params)
319 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
320 let result = self.invoker.invoke("doc.getHtml", params, options).await?;
321 serde_json::from_value(result).map_err(|decode| {
322 let mut error = Error::decode(decode);
323 error.operation_id = Some("doc.getHtml".to_owned());
324 error.outcome_unknown = false;
325 error
326 })
327 }
328
329 pub async fn get_markdown(
330 &self,
331 params: &DocGetMarkdownBoundParams,
332 ) -> Result<DocGetMarkdownResult> {
333 self.get_markdown_with_options(params, InvokeOptions::default())
334 .await
335 }
336 pub async fn get_markdown_with_options(
337 &self,
338 params: &DocGetMarkdownBoundParams,
339 options: InvokeOptions,
340 ) -> Result<DocGetMarkdownResult> {
341 let params = serde_json::to_value(params)
342 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
343 let result = self
344 .invoker
345 .invoke("doc.getMarkdown", params, options)
346 .await?;
347 serde_json::from_value(result).map_err(|decode| {
348 let mut error = Error::decode(decode);
349 error.operation_id = Some("doc.getMarkdown".to_owned());
350 error.outcome_unknown = false;
351 error
352 })
353 }
354
355 pub async fn get_node(&self, params: &DocGetNodeBoundParams) -> Result<DocGetNodeResult> {
356 self.get_node_with_options(params, InvokeOptions::default())
357 .await
358 }
359 pub async fn get_node_with_options(
360 &self,
361 params: &DocGetNodeBoundParams,
362 options: InvokeOptions,
363 ) -> Result<DocGetNodeResult> {
364 let params = serde_json::to_value(params)
365 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
366 let result = self.invoker.invoke("doc.getNode", params, options).await?;
367 serde_json::from_value(result).map_err(|decode| {
368 let mut error = Error::decode(decode);
369 error.operation_id = Some("doc.getNode".to_owned());
370 error.outcome_unknown = false;
371 error
372 })
373 }
374
375 pub async fn get_node_by_id(
376 &self,
377 params: &DocGetNodeByIdBoundParams,
378 ) -> Result<DocGetNodeByIdResult> {
379 self.get_node_by_id_with_options(params, InvokeOptions::default())
380 .await
381 }
382 pub async fn get_node_by_id_with_options(
383 &self,
384 params: &DocGetNodeByIdBoundParams,
385 options: InvokeOptions,
386 ) -> Result<DocGetNodeByIdResult> {
387 let params = serde_json::to_value(params)
388 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
389 let result = self
390 .invoker
391 .invoke("doc.getNodeById", params, options)
392 .await?;
393 serde_json::from_value(result).map_err(|decode| {
394 let mut error = Error::decode(decode);
395 error.operation_id = Some("doc.getNodeById".to_owned());
396 error.outcome_unknown = false;
397 error
398 })
399 }
400
401 pub async fn get_text(&self, params: &DocGetTextBoundParams) -> Result<DocGetTextResult> {
402 self.get_text_with_options(params, InvokeOptions::default())
403 .await
404 }
405 pub async fn get_text_with_options(
406 &self,
407 params: &DocGetTextBoundParams,
408 options: InvokeOptions,
409 ) -> Result<DocGetTextResult> {
410 let params = serde_json::to_value(params)
411 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
412 let result = self.invoker.invoke("doc.getText", params, options).await?;
413 serde_json::from_value(result).map_err(|decode| {
414 let mut error = Error::decode(decode);
415 error.operation_id = Some("doc.getText".to_owned());
416 error.outcome_unknown = false;
417 error
418 })
419 }
420
421 pub async fn html_to_fragment(
422 &self,
423 params: &DocHtmlToFragmentBoundParams,
424 ) -> Result<DocHtmlToFragmentResult> {
425 self.html_to_fragment_with_options(params, InvokeOptions::default())
426 .await
427 }
428 pub async fn html_to_fragment_with_options(
429 &self,
430 params: &DocHtmlToFragmentBoundParams,
431 options: InvokeOptions,
432 ) -> Result<DocHtmlToFragmentResult> {
433 let params = serde_json::to_value(params)
434 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
435 let result = self
436 .invoker
437 .invoke("doc.htmlToFragment", params, options)
438 .await?;
439 serde_json::from_value(result).map_err(|decode| {
440 let mut error = Error::decode(decode);
441 error.operation_id = Some("doc.htmlToFragment".to_owned());
442 error.outcome_unknown = false;
443 error
444 })
445 }
446
447 pub async fn info(&self, params: &DocInfoBoundParams) -> Result<DocInfoResult> {
448 self.info_with_options(params, InvokeOptions::default())
449 .await
450 }
451 pub async fn info_with_options(
452 &self,
453 params: &DocInfoBoundParams,
454 options: InvokeOptions,
455 ) -> Result<DocInfoResult> {
456 let params = serde_json::to_value(params)
457 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
458 let result = self.invoker.invoke("doc.info", params, options).await?;
459 serde_json::from_value(result).map_err(|decode| {
460 let mut error = Error::decode(decode);
461 error.operation_id = Some("doc.info".to_owned());
462 error.outcome_unknown = false;
463 error
464 })
465 }
466
467 pub async fn insert(&self, params: &DocInsertBoundParams) -> Result<DocInsertResult> {
468 self.insert_with_options(params, InvokeOptions::default())
469 .await
470 }
471 pub async fn insert_with_options(
472 &self,
473 params: &DocInsertBoundParams,
474 options: InvokeOptions,
475 ) -> Result<DocInsertResult> {
476 let params = serde_json::to_value(params)
477 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
478 let result = self.invoker.invoke("doc.insert", params, options).await?;
479 serde_json::from_value(result).map_err(|decode| {
480 let mut error = Error::decode(decode);
481 error.operation_id = Some("doc.insert".to_owned());
482 error.outcome_unknown = true;
483 error
484 })
485 }
486
487 pub async fn insert_line_break(
488 &self,
489 params: &DocInsertLineBreakBoundParams,
490 ) -> Result<DocInsertLineBreakResult> {
491 self.insert_line_break_with_options(params, InvokeOptions::default())
492 .await
493 }
494 pub async fn insert_line_break_with_options(
495 &self,
496 params: &DocInsertLineBreakBoundParams,
497 options: InvokeOptions,
498 ) -> Result<DocInsertLineBreakResult> {
499 let params = serde_json::to_value(params)
500 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
501 let result = self
502 .invoker
503 .invoke("doc.insertLineBreak", params, options)
504 .await?;
505 serde_json::from_value(result).map_err(|decode| {
506 let mut error = Error::decode(decode);
507 error.operation_id = Some("doc.insertLineBreak".to_owned());
508 error.outcome_unknown = true;
509 error
510 })
511 }
512
513 pub async fn insert_tab(&self, params: &DocInsertTabBoundParams) -> Result<DocInsertTabResult> {
514 self.insert_tab_with_options(params, InvokeOptions::default())
515 .await
516 }
517 pub async fn insert_tab_with_options(
518 &self,
519 params: &DocInsertTabBoundParams,
520 options: InvokeOptions,
521 ) -> Result<DocInsertTabResult> {
522 let params = serde_json::to_value(params)
523 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
524 let result = self
525 .invoker
526 .invoke("doc.insertTab", params, options)
527 .await?;
528 serde_json::from_value(result).map_err(|decode| {
529 let mut error = Error::decode(decode);
530 error.operation_id = Some("doc.insertTab".to_owned());
531 error.outcome_unknown = true;
532 error
533 })
534 }
535
536 pub async fn markdown_to_fragment(
537 &self,
538 params: &DocMarkdownToFragmentBoundParams,
539 ) -> Result<DocMarkdownToFragmentResult> {
540 self.markdown_to_fragment_with_options(params, InvokeOptions::default())
541 .await
542 }
543 pub async fn markdown_to_fragment_with_options(
544 &self,
545 params: &DocMarkdownToFragmentBoundParams,
546 options: InvokeOptions,
547 ) -> Result<DocMarkdownToFragmentResult> {
548 let params = serde_json::to_value(params)
549 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
550 let result = self
551 .invoker
552 .invoke("doc.markdownToFragment", params, options)
553 .await?;
554 serde_json::from_value(result).map_err(|decode| {
555 let mut error = Error::decode(decode);
556 error.operation_id = Some("doc.markdownToFragment".to_owned());
557 error.outcome_unknown = false;
558 error
559 })
560 }
561
562 pub async fn project_html(
563 &self,
564 params: &DocProjectHtmlBoundParams,
565 ) -> Result<DocProjectHtmlResult> {
566 self.project_html_with_options(params, InvokeOptions::default())
567 .await
568 }
569 pub async fn project_html_with_options(
570 &self,
571 params: &DocProjectHtmlBoundParams,
572 options: InvokeOptions,
573 ) -> Result<DocProjectHtmlResult> {
574 let params = serde_json::to_value(params)
575 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
576 let result = self
577 .invoker
578 .invoke("doc.projectHtml", params, options)
579 .await?;
580 serde_json::from_value(result).map_err(|decode| {
581 let mut error = Error::decode(decode);
582 error.operation_id = Some("doc.projectHtml".to_owned());
583 error.outcome_unknown = false;
584 error
585 })
586 }
587
588 pub async fn project_markdown(
589 &self,
590 params: &DocProjectMarkdownBoundParams,
591 ) -> Result<DocProjectMarkdownResult> {
592 self.project_markdown_with_options(params, InvokeOptions::default())
593 .await
594 }
595 pub async fn project_markdown_with_options(
596 &self,
597 params: &DocProjectMarkdownBoundParams,
598 options: InvokeOptions,
599 ) -> Result<DocProjectMarkdownResult> {
600 let params = serde_json::to_value(params)
601 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
602 let result = self
603 .invoker
604 .invoke("doc.projectMarkdown", params, options)
605 .await?;
606 serde_json::from_value(result).map_err(|decode| {
607 let mut error = Error::decode(decode);
608 error.operation_id = Some("doc.projectMarkdown".to_owned());
609 error.outcome_unknown = false;
610 error
611 })
612 }
613
614 pub async fn replace(&self, params: &DocReplaceBoundParams) -> Result<DocReplaceResult> {
615 self.replace_with_options(params, InvokeOptions::default())
616 .await
617 }
618 pub async fn replace_with_options(
619 &self,
620 params: &DocReplaceBoundParams,
621 options: InvokeOptions,
622 ) -> Result<DocReplaceResult> {
623 let params = serde_json::to_value(params)
624 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
625 let result = self.invoker.invoke("doc.replace", params, options).await?;
626 serde_json::from_value(result).map_err(|decode| {
627 let mut error = Error::decode(decode);
628 error.operation_id = Some("doc.replace".to_owned());
629 error.outcome_unknown = true;
630 error
631 })
632 }
633
634 pub async fn save(&self, params: &DocSaveBoundParams) -> Result<DocSaveResult> {
635 self.save_with_options(params, InvokeOptions::default())
636 .await
637 }
638 pub async fn save_with_options(
639 &self,
640 params: &DocSaveBoundParams,
641 options: InvokeOptions,
642 ) -> Result<DocSaveResult> {
643 let params = serde_json::to_value(params)
644 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
645 let result = self.invoker.invoke("doc.save", params, options).await?;
646 serde_json::from_value(result).map_err(|decode| {
647 let mut error = Error::decode(decode);
648 error.operation_id = Some("doc.save".to_owned());
649 error.outcome_unknown = true;
650 error
651 })
652 }
653}
654
655pub struct DocApiAuthorities<'a, I: Invoker> {
656 invoker: &'a I,
657}
658impl<'a, I: Invoker> DocApiAuthorities<'a, I> {
659 pub fn new(invoker: &'a I) -> Self {
660 Self { invoker }
661 }
662 pub fn entries(&self) -> DocApiAuthoritiesEntries<'a, I> {
663 DocApiAuthoritiesEntries::new(self.invoker)
664 }
665
666 pub async fn configure(
667 &self,
668 params: &DocAuthoritiesConfigureBoundParams,
669 ) -> Result<DocAuthoritiesConfigureResult> {
670 self.configure_with_options(params, InvokeOptions::default())
671 .await
672 }
673 pub async fn configure_with_options(
674 &self,
675 params: &DocAuthoritiesConfigureBoundParams,
676 options: InvokeOptions,
677 ) -> Result<DocAuthoritiesConfigureResult> {
678 let params = serde_json::to_value(params)
679 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
680 let result = self
681 .invoker
682 .invoke("doc.authorities.configure", params, options)
683 .await?;
684 serde_json::from_value(result).map_err(|decode| {
685 let mut error = Error::decode(decode);
686 error.operation_id = Some("doc.authorities.configure".to_owned());
687 error.outcome_unknown = true;
688 error
689 })
690 }
691
692 pub async fn get(
693 &self,
694 params: &DocAuthoritiesGetBoundParams,
695 ) -> Result<DocAuthoritiesGetResult> {
696 self.get_with_options(params, InvokeOptions::default())
697 .await
698 }
699 pub async fn get_with_options(
700 &self,
701 params: &DocAuthoritiesGetBoundParams,
702 options: InvokeOptions,
703 ) -> Result<DocAuthoritiesGetResult> {
704 let params = serde_json::to_value(params)
705 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
706 let result = self
707 .invoker
708 .invoke("doc.authorities.get", params, options)
709 .await?;
710 serde_json::from_value(result).map_err(|decode| {
711 let mut error = Error::decode(decode);
712 error.operation_id = Some("doc.authorities.get".to_owned());
713 error.outcome_unknown = false;
714 error
715 })
716 }
717
718 pub async fn insert(
719 &self,
720 params: &DocAuthoritiesInsertBoundParams,
721 ) -> Result<DocAuthoritiesInsertResult> {
722 self.insert_with_options(params, InvokeOptions::default())
723 .await
724 }
725 pub async fn insert_with_options(
726 &self,
727 params: &DocAuthoritiesInsertBoundParams,
728 options: InvokeOptions,
729 ) -> Result<DocAuthoritiesInsertResult> {
730 let params = serde_json::to_value(params)
731 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
732 let result = self
733 .invoker
734 .invoke("doc.authorities.insert", params, options)
735 .await?;
736 serde_json::from_value(result).map_err(|decode| {
737 let mut error = Error::decode(decode);
738 error.operation_id = Some("doc.authorities.insert".to_owned());
739 error.outcome_unknown = true;
740 error
741 })
742 }
743
744 pub async fn list(
745 &self,
746 params: &DocAuthoritiesListBoundParams,
747 ) -> Result<DocAuthoritiesListResult> {
748 self.list_with_options(params, InvokeOptions::default())
749 .await
750 }
751 pub async fn list_with_options(
752 &self,
753 params: &DocAuthoritiesListBoundParams,
754 options: InvokeOptions,
755 ) -> Result<DocAuthoritiesListResult> {
756 let params = serde_json::to_value(params)
757 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
758 let result = self
759 .invoker
760 .invoke("doc.authorities.list", params, options)
761 .await?;
762 serde_json::from_value(result).map_err(|decode| {
763 let mut error = Error::decode(decode);
764 error.operation_id = Some("doc.authorities.list".to_owned());
765 error.outcome_unknown = false;
766 error
767 })
768 }
769
770 pub async fn rebuild(
771 &self,
772 params: &DocAuthoritiesRebuildBoundParams,
773 ) -> Result<DocAuthoritiesRebuildResult> {
774 self.rebuild_with_options(params, InvokeOptions::default())
775 .await
776 }
777 pub async fn rebuild_with_options(
778 &self,
779 params: &DocAuthoritiesRebuildBoundParams,
780 options: InvokeOptions,
781 ) -> Result<DocAuthoritiesRebuildResult> {
782 let params = serde_json::to_value(params)
783 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
784 let result = self
785 .invoker
786 .invoke("doc.authorities.rebuild", params, options)
787 .await?;
788 serde_json::from_value(result).map_err(|decode| {
789 let mut error = Error::decode(decode);
790 error.operation_id = Some("doc.authorities.rebuild".to_owned());
791 error.outcome_unknown = true;
792 error
793 })
794 }
795
796 pub async fn remove(
797 &self,
798 params: &DocAuthoritiesRemoveBoundParams,
799 ) -> Result<DocAuthoritiesRemoveResult> {
800 self.remove_with_options(params, InvokeOptions::default())
801 .await
802 }
803 pub async fn remove_with_options(
804 &self,
805 params: &DocAuthoritiesRemoveBoundParams,
806 options: InvokeOptions,
807 ) -> Result<DocAuthoritiesRemoveResult> {
808 let params = serde_json::to_value(params)
809 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
810 let result = self
811 .invoker
812 .invoke("doc.authorities.remove", params, options)
813 .await?;
814 serde_json::from_value(result).map_err(|decode| {
815 let mut error = Error::decode(decode);
816 error.operation_id = Some("doc.authorities.remove".to_owned());
817 error.outcome_unknown = true;
818 error
819 })
820 }
821}
822
823pub struct DocApiAuthoritiesEntries<'a, I: Invoker> {
824 invoker: &'a I,
825}
826impl<'a, I: Invoker> DocApiAuthoritiesEntries<'a, I> {
827 pub fn new(invoker: &'a I) -> Self {
828 Self { invoker }
829 }
830
831 pub async fn get(
832 &self,
833 params: &DocAuthoritiesEntriesGetBoundParams,
834 ) -> Result<DocAuthoritiesEntriesGetResult> {
835 self.get_with_options(params, InvokeOptions::default())
836 .await
837 }
838 pub async fn get_with_options(
839 &self,
840 params: &DocAuthoritiesEntriesGetBoundParams,
841 options: InvokeOptions,
842 ) -> Result<DocAuthoritiesEntriesGetResult> {
843 let params = serde_json::to_value(params)
844 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
845 let result = self
846 .invoker
847 .invoke("doc.authorities.entries.get", params, options)
848 .await?;
849 serde_json::from_value(result).map_err(|decode| {
850 let mut error = Error::decode(decode);
851 error.operation_id = Some("doc.authorities.entries.get".to_owned());
852 error.outcome_unknown = false;
853 error
854 })
855 }
856
857 pub async fn insert(
858 &self,
859 params: &DocAuthoritiesEntriesInsertBoundParams,
860 ) -> Result<DocAuthoritiesEntriesInsertResult> {
861 self.insert_with_options(params, InvokeOptions::default())
862 .await
863 }
864 pub async fn insert_with_options(
865 &self,
866 params: &DocAuthoritiesEntriesInsertBoundParams,
867 options: InvokeOptions,
868 ) -> Result<DocAuthoritiesEntriesInsertResult> {
869 let params = serde_json::to_value(params)
870 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
871 let result = self
872 .invoker
873 .invoke("doc.authorities.entries.insert", params, options)
874 .await?;
875 serde_json::from_value(result).map_err(|decode| {
876 let mut error = Error::decode(decode);
877 error.operation_id = Some("doc.authorities.entries.insert".to_owned());
878 error.outcome_unknown = true;
879 error
880 })
881 }
882
883 pub async fn list(
884 &self,
885 params: &DocAuthoritiesEntriesListBoundParams,
886 ) -> Result<DocAuthoritiesEntriesListResult> {
887 self.list_with_options(params, InvokeOptions::default())
888 .await
889 }
890 pub async fn list_with_options(
891 &self,
892 params: &DocAuthoritiesEntriesListBoundParams,
893 options: InvokeOptions,
894 ) -> Result<DocAuthoritiesEntriesListResult> {
895 let params = serde_json::to_value(params)
896 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
897 let result = self
898 .invoker
899 .invoke("doc.authorities.entries.list", params, options)
900 .await?;
901 serde_json::from_value(result).map_err(|decode| {
902 let mut error = Error::decode(decode);
903 error.operation_id = Some("doc.authorities.entries.list".to_owned());
904 error.outcome_unknown = false;
905 error
906 })
907 }
908
909 pub async fn remove(
910 &self,
911 params: &DocAuthoritiesEntriesRemoveBoundParams,
912 ) -> Result<DocAuthoritiesEntriesRemoveResult> {
913 self.remove_with_options(params, InvokeOptions::default())
914 .await
915 }
916 pub async fn remove_with_options(
917 &self,
918 params: &DocAuthoritiesEntriesRemoveBoundParams,
919 options: InvokeOptions,
920 ) -> Result<DocAuthoritiesEntriesRemoveResult> {
921 let params = serde_json::to_value(params)
922 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
923 let result = self
924 .invoker
925 .invoke("doc.authorities.entries.remove", params, options)
926 .await?;
927 serde_json::from_value(result).map_err(|decode| {
928 let mut error = Error::decode(decode);
929 error.operation_id = Some("doc.authorities.entries.remove".to_owned());
930 error.outcome_unknown = true;
931 error
932 })
933 }
934
935 pub async fn update(
936 &self,
937 params: &DocAuthoritiesEntriesUpdateBoundParams,
938 ) -> Result<DocAuthoritiesEntriesUpdateResult> {
939 self.update_with_options(params, InvokeOptions::default())
940 .await
941 }
942 pub async fn update_with_options(
943 &self,
944 params: &DocAuthoritiesEntriesUpdateBoundParams,
945 options: InvokeOptions,
946 ) -> Result<DocAuthoritiesEntriesUpdateResult> {
947 let params = serde_json::to_value(params)
948 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
949 let result = self
950 .invoker
951 .invoke("doc.authorities.entries.update", params, options)
952 .await?;
953 serde_json::from_value(result).map_err(|decode| {
954 let mut error = Error::decode(decode);
955 error.operation_id = Some("doc.authorities.entries.update".to_owned());
956 error.outcome_unknown = true;
957 error
958 })
959 }
960}
961
962pub struct DocApiBlocks<'a, I: Invoker> {
963 invoker: &'a I,
964}
965impl<'a, I: Invoker> DocApiBlocks<'a, I> {
966 pub fn new(invoker: &'a I) -> Self {
967 Self { invoker }
968 }
969
970 pub async fn delete(
971 &self,
972 params: &DocBlocksDeleteBoundParams,
973 ) -> Result<DocBlocksDeleteResult> {
974 self.delete_with_options(params, InvokeOptions::default())
975 .await
976 }
977 pub async fn delete_with_options(
978 &self,
979 params: &DocBlocksDeleteBoundParams,
980 options: InvokeOptions,
981 ) -> Result<DocBlocksDeleteResult> {
982 let params = serde_json::to_value(params)
983 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
984 let result = self
985 .invoker
986 .invoke("doc.blocks.delete", params, options)
987 .await?;
988 serde_json::from_value(result).map_err(|decode| {
989 let mut error = Error::decode(decode);
990 error.operation_id = Some("doc.blocks.delete".to_owned());
991 error.outcome_unknown = true;
992 error
993 })
994 }
995
996 pub async fn delete_range(
997 &self,
998 params: &DocBlocksDeleteRangeBoundParams,
999 ) -> Result<DocBlocksDeleteRangeResult> {
1000 self.delete_range_with_options(params, InvokeOptions::default())
1001 .await
1002 }
1003 pub async fn delete_range_with_options(
1004 &self,
1005 params: &DocBlocksDeleteRangeBoundParams,
1006 options: InvokeOptions,
1007 ) -> Result<DocBlocksDeleteRangeResult> {
1008 let params = serde_json::to_value(params)
1009 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1010 let result = self
1011 .invoker
1012 .invoke("doc.blocks.deleteRange", params, options)
1013 .await?;
1014 serde_json::from_value(result).map_err(|decode| {
1015 let mut error = Error::decode(decode);
1016 error.operation_id = Some("doc.blocks.deleteRange".to_owned());
1017 error.outcome_unknown = true;
1018 error
1019 })
1020 }
1021
1022 pub async fn find_text(
1023 &self,
1024 params: &DocBlocksFindTextBoundParams,
1025 ) -> Result<DocBlocksFindTextResult> {
1026 self.find_text_with_options(params, InvokeOptions::default())
1027 .await
1028 }
1029 pub async fn find_text_with_options(
1030 &self,
1031 params: &DocBlocksFindTextBoundParams,
1032 options: InvokeOptions,
1033 ) -> Result<DocBlocksFindTextResult> {
1034 let params = serde_json::to_value(params)
1035 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1036 let result = self
1037 .invoker
1038 .invoke("doc.blocks.findText", params, options)
1039 .await?;
1040 serde_json::from_value(result).map_err(|decode| {
1041 let mut error = Error::decode(decode);
1042 error.operation_id = Some("doc.blocks.findText".to_owned());
1043 error.outcome_unknown = false;
1044 error
1045 })
1046 }
1047
1048 pub async fn list(&self, params: &DocBlocksListBoundParams) -> Result<DocBlocksListResult> {
1049 self.list_with_options(params, InvokeOptions::default())
1050 .await
1051 }
1052 pub async fn list_with_options(
1053 &self,
1054 params: &DocBlocksListBoundParams,
1055 options: InvokeOptions,
1056 ) -> Result<DocBlocksListResult> {
1057 let params = serde_json::to_value(params)
1058 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1059 let result = self
1060 .invoker
1061 .invoke("doc.blocks.list", params, options)
1062 .await?;
1063 serde_json::from_value(result).map_err(|decode| {
1064 let mut error = Error::decode(decode);
1065 error.operation_id = Some("doc.blocks.list".to_owned());
1066 error.outcome_unknown = false;
1067 error
1068 })
1069 }
1070
1071 pub async fn merge(&self, params: &DocBlocksMergeBoundParams) -> Result<DocBlocksMergeResult> {
1072 self.merge_with_options(params, InvokeOptions::default())
1073 .await
1074 }
1075 pub async fn merge_with_options(
1076 &self,
1077 params: &DocBlocksMergeBoundParams,
1078 options: InvokeOptions,
1079 ) -> Result<DocBlocksMergeResult> {
1080 let params = serde_json::to_value(params)
1081 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1082 let result = self
1083 .invoker
1084 .invoke("doc.blocks.merge", params, options)
1085 .await?;
1086 serde_json::from_value(result).map_err(|decode| {
1087 let mut error = Error::decode(decode);
1088 error.operation_id = Some("doc.blocks.merge".to_owned());
1089 error.outcome_unknown = true;
1090 error
1091 })
1092 }
1093
1094 pub async fn move_(&self, params: &DocBlocksMoveBoundParams) -> Result<DocBlocksMoveResult> {
1095 self.move_with_options(params, InvokeOptions::default())
1096 .await
1097 }
1098 pub async fn move_with_options(
1099 &self,
1100 params: &DocBlocksMoveBoundParams,
1101 options: InvokeOptions,
1102 ) -> Result<DocBlocksMoveResult> {
1103 let params = serde_json::to_value(params)
1104 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1105 let result = self
1106 .invoker
1107 .invoke("doc.blocks.move", params, options)
1108 .await?;
1109 serde_json::from_value(result).map_err(|decode| {
1110 let mut error = Error::decode(decode);
1111 error.operation_id = Some("doc.blocks.move".to_owned());
1112 error.outcome_unknown = true;
1113 error
1114 })
1115 }
1116
1117 pub async fn split(&self, params: &DocBlocksSplitBoundParams) -> Result<DocBlocksSplitResult> {
1118 self.split_with_options(params, InvokeOptions::default())
1119 .await
1120 }
1121 pub async fn split_with_options(
1122 &self,
1123 params: &DocBlocksSplitBoundParams,
1124 options: InvokeOptions,
1125 ) -> Result<DocBlocksSplitResult> {
1126 let params = serde_json::to_value(params)
1127 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1128 let result = self
1129 .invoker
1130 .invoke("doc.blocks.split", params, options)
1131 .await?;
1132 serde_json::from_value(result).map_err(|decode| {
1133 let mut error = Error::decode(decode);
1134 error.operation_id = Some("doc.blocks.split".to_owned());
1135 error.outcome_unknown = true;
1136 error
1137 })
1138 }
1139}
1140
1141pub struct DocApiBookmarks<'a, I: Invoker> {
1142 invoker: &'a I,
1143}
1144impl<'a, I: Invoker> DocApiBookmarks<'a, I> {
1145 pub fn new(invoker: &'a I) -> Self {
1146 Self { invoker }
1147 }
1148
1149 pub async fn get(&self, params: &DocBookmarksGetBoundParams) -> Result<DocBookmarksGetResult> {
1150 self.get_with_options(params, InvokeOptions::default())
1151 .await
1152 }
1153 pub async fn get_with_options(
1154 &self,
1155 params: &DocBookmarksGetBoundParams,
1156 options: InvokeOptions,
1157 ) -> Result<DocBookmarksGetResult> {
1158 let params = serde_json::to_value(params)
1159 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1160 let result = self
1161 .invoker
1162 .invoke("doc.bookmarks.get", params, options)
1163 .await?;
1164 serde_json::from_value(result).map_err(|decode| {
1165 let mut error = Error::decode(decode);
1166 error.operation_id = Some("doc.bookmarks.get".to_owned());
1167 error.outcome_unknown = false;
1168 error
1169 })
1170 }
1171
1172 pub async fn insert(
1173 &self,
1174 params: &DocBookmarksInsertBoundParams,
1175 ) -> Result<DocBookmarksInsertResult> {
1176 self.insert_with_options(params, InvokeOptions::default())
1177 .await
1178 }
1179 pub async fn insert_with_options(
1180 &self,
1181 params: &DocBookmarksInsertBoundParams,
1182 options: InvokeOptions,
1183 ) -> Result<DocBookmarksInsertResult> {
1184 let params = serde_json::to_value(params)
1185 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1186 let result = self
1187 .invoker
1188 .invoke("doc.bookmarks.insert", params, options)
1189 .await?;
1190 serde_json::from_value(result).map_err(|decode| {
1191 let mut error = Error::decode(decode);
1192 error.operation_id = Some("doc.bookmarks.insert".to_owned());
1193 error.outcome_unknown = true;
1194 error
1195 })
1196 }
1197
1198 pub async fn list(
1199 &self,
1200 params: &DocBookmarksListBoundParams,
1201 ) -> Result<DocBookmarksListResult> {
1202 self.list_with_options(params, InvokeOptions::default())
1203 .await
1204 }
1205 pub async fn list_with_options(
1206 &self,
1207 params: &DocBookmarksListBoundParams,
1208 options: InvokeOptions,
1209 ) -> Result<DocBookmarksListResult> {
1210 let params = serde_json::to_value(params)
1211 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1212 let result = self
1213 .invoker
1214 .invoke("doc.bookmarks.list", params, options)
1215 .await?;
1216 serde_json::from_value(result).map_err(|decode| {
1217 let mut error = Error::decode(decode);
1218 error.operation_id = Some("doc.bookmarks.list".to_owned());
1219 error.outcome_unknown = false;
1220 error
1221 })
1222 }
1223
1224 pub async fn remove(
1225 &self,
1226 params: &DocBookmarksRemoveBoundParams,
1227 ) -> Result<DocBookmarksRemoveResult> {
1228 self.remove_with_options(params, InvokeOptions::default())
1229 .await
1230 }
1231 pub async fn remove_with_options(
1232 &self,
1233 params: &DocBookmarksRemoveBoundParams,
1234 options: InvokeOptions,
1235 ) -> Result<DocBookmarksRemoveResult> {
1236 let params = serde_json::to_value(params)
1237 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1238 let result = self
1239 .invoker
1240 .invoke("doc.bookmarks.remove", params, options)
1241 .await?;
1242 serde_json::from_value(result).map_err(|decode| {
1243 let mut error = Error::decode(decode);
1244 error.operation_id = Some("doc.bookmarks.remove".to_owned());
1245 error.outcome_unknown = true;
1246 error
1247 })
1248 }
1249
1250 pub async fn rename(
1251 &self,
1252 params: &DocBookmarksRenameBoundParams,
1253 ) -> Result<DocBookmarksRenameResult> {
1254 self.rename_with_options(params, InvokeOptions::default())
1255 .await
1256 }
1257 pub async fn rename_with_options(
1258 &self,
1259 params: &DocBookmarksRenameBoundParams,
1260 options: InvokeOptions,
1261 ) -> Result<DocBookmarksRenameResult> {
1262 let params = serde_json::to_value(params)
1263 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1264 let result = self
1265 .invoker
1266 .invoke("doc.bookmarks.rename", params, options)
1267 .await?;
1268 serde_json::from_value(result).map_err(|decode| {
1269 let mut error = Error::decode(decode);
1270 error.operation_id = Some("doc.bookmarks.rename".to_owned());
1271 error.outcome_unknown = true;
1272 error
1273 })
1274 }
1275}
1276
1277pub struct DocApiCapabilities<'a, I: Invoker> {
1278 invoker: &'a I,
1279}
1280impl<'a, I: Invoker> DocApiCapabilities<'a, I> {
1281 pub fn new(invoker: &'a I) -> Self {
1282 Self { invoker }
1283 }
1284
1285 pub async fn check(
1286 &self,
1287 params: &DocCapabilitiesCheckBoundParams,
1288 ) -> Result<DocCapabilitiesCheckResult> {
1289 self.check_with_options(params, InvokeOptions::default())
1290 .await
1291 }
1292 pub async fn check_with_options(
1293 &self,
1294 params: &DocCapabilitiesCheckBoundParams,
1295 options: InvokeOptions,
1296 ) -> Result<DocCapabilitiesCheckResult> {
1297 let params = serde_json::to_value(params)
1298 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1299 let result = self
1300 .invoker
1301 .invoke("doc.capabilities.check", params, options)
1302 .await?;
1303 serde_json::from_value(result).map_err(|decode| {
1304 let mut error = Error::decode(decode);
1305 error.operation_id = Some("doc.capabilities.check".to_owned());
1306 error.outcome_unknown = false;
1307 error
1308 })
1309 }
1310
1311 pub async fn get(
1312 &self,
1313 params: &DocCapabilitiesGetBoundParams,
1314 ) -> Result<DocCapabilitiesGetResult> {
1315 self.get_with_options(params, InvokeOptions::default())
1316 .await
1317 }
1318 pub async fn get_with_options(
1319 &self,
1320 params: &DocCapabilitiesGetBoundParams,
1321 options: InvokeOptions,
1322 ) -> Result<DocCapabilitiesGetResult> {
1323 let params = serde_json::to_value(params)
1324 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1325 let result = self
1326 .invoker
1327 .invoke("doc.capabilities.get", params, options)
1328 .await?;
1329 serde_json::from_value(result).map_err(|decode| {
1330 let mut error = Error::decode(decode);
1331 error.operation_id = Some("doc.capabilities.get".to_owned());
1332 error.outcome_unknown = false;
1333 error
1334 })
1335 }
1336
1337 pub async fn resolve(
1338 &self,
1339 params: &DocCapabilitiesResolveBoundParams,
1340 ) -> Result<DocCapabilitiesResolveResult> {
1341 self.resolve_with_options(params, InvokeOptions::default())
1342 .await
1343 }
1344 pub async fn resolve_with_options(
1345 &self,
1346 params: &DocCapabilitiesResolveBoundParams,
1347 options: InvokeOptions,
1348 ) -> Result<DocCapabilitiesResolveResult> {
1349 let params = serde_json::to_value(params)
1350 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1351 let result = self
1352 .invoker
1353 .invoke("doc.capabilities.resolve", params, options)
1354 .await?;
1355 serde_json::from_value(result).map_err(|decode| {
1356 let mut error = Error::decode(decode);
1357 error.operation_id = Some("doc.capabilities.resolve".to_owned());
1358 error.outcome_unknown = false;
1359 error
1360 })
1361 }
1362}
1363
1364pub struct DocApiCaptions<'a, I: Invoker> {
1365 invoker: &'a I,
1366}
1367impl<'a, I: Invoker> DocApiCaptions<'a, I> {
1368 pub fn new(invoker: &'a I) -> Self {
1369 Self { invoker }
1370 }
1371
1372 pub async fn configure(
1373 &self,
1374 params: &DocCaptionsConfigureBoundParams,
1375 ) -> Result<DocCaptionsConfigureResult> {
1376 self.configure_with_options(params, InvokeOptions::default())
1377 .await
1378 }
1379 pub async fn configure_with_options(
1380 &self,
1381 params: &DocCaptionsConfigureBoundParams,
1382 options: InvokeOptions,
1383 ) -> Result<DocCaptionsConfigureResult> {
1384 let params = serde_json::to_value(params)
1385 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1386 let result = self
1387 .invoker
1388 .invoke("doc.captions.configure", params, options)
1389 .await?;
1390 serde_json::from_value(result).map_err(|decode| {
1391 let mut error = Error::decode(decode);
1392 error.operation_id = Some("doc.captions.configure".to_owned());
1393 error.outcome_unknown = true;
1394 error
1395 })
1396 }
1397
1398 pub async fn get(&self, params: &DocCaptionsGetBoundParams) -> Result<DocCaptionsGetResult> {
1399 self.get_with_options(params, InvokeOptions::default())
1400 .await
1401 }
1402 pub async fn get_with_options(
1403 &self,
1404 params: &DocCaptionsGetBoundParams,
1405 options: InvokeOptions,
1406 ) -> Result<DocCaptionsGetResult> {
1407 let params = serde_json::to_value(params)
1408 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1409 let result = self
1410 .invoker
1411 .invoke("doc.captions.get", params, options)
1412 .await?;
1413 serde_json::from_value(result).map_err(|decode| {
1414 let mut error = Error::decode(decode);
1415 error.operation_id = Some("doc.captions.get".to_owned());
1416 error.outcome_unknown = false;
1417 error
1418 })
1419 }
1420
1421 pub async fn insert(
1422 &self,
1423 params: &DocCaptionsInsertBoundParams,
1424 ) -> Result<DocCaptionsInsertResult> {
1425 self.insert_with_options(params, InvokeOptions::default())
1426 .await
1427 }
1428 pub async fn insert_with_options(
1429 &self,
1430 params: &DocCaptionsInsertBoundParams,
1431 options: InvokeOptions,
1432 ) -> Result<DocCaptionsInsertResult> {
1433 let params = serde_json::to_value(params)
1434 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1435 let result = self
1436 .invoker
1437 .invoke("doc.captions.insert", params, options)
1438 .await?;
1439 serde_json::from_value(result).map_err(|decode| {
1440 let mut error = Error::decode(decode);
1441 error.operation_id = Some("doc.captions.insert".to_owned());
1442 error.outcome_unknown = true;
1443 error
1444 })
1445 }
1446
1447 pub async fn list(&self, params: &DocCaptionsListBoundParams) -> Result<DocCaptionsListResult> {
1448 self.list_with_options(params, InvokeOptions::default())
1449 .await
1450 }
1451 pub async fn list_with_options(
1452 &self,
1453 params: &DocCaptionsListBoundParams,
1454 options: InvokeOptions,
1455 ) -> Result<DocCaptionsListResult> {
1456 let params = serde_json::to_value(params)
1457 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1458 let result = self
1459 .invoker
1460 .invoke("doc.captions.list", params, options)
1461 .await?;
1462 serde_json::from_value(result).map_err(|decode| {
1463 let mut error = Error::decode(decode);
1464 error.operation_id = Some("doc.captions.list".to_owned());
1465 error.outcome_unknown = false;
1466 error
1467 })
1468 }
1469
1470 pub async fn remove(
1471 &self,
1472 params: &DocCaptionsRemoveBoundParams,
1473 ) -> Result<DocCaptionsRemoveResult> {
1474 self.remove_with_options(params, InvokeOptions::default())
1475 .await
1476 }
1477 pub async fn remove_with_options(
1478 &self,
1479 params: &DocCaptionsRemoveBoundParams,
1480 options: InvokeOptions,
1481 ) -> Result<DocCaptionsRemoveResult> {
1482 let params = serde_json::to_value(params)
1483 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1484 let result = self
1485 .invoker
1486 .invoke("doc.captions.remove", params, options)
1487 .await?;
1488 serde_json::from_value(result).map_err(|decode| {
1489 let mut error = Error::decode(decode);
1490 error.operation_id = Some("doc.captions.remove".to_owned());
1491 error.outcome_unknown = true;
1492 error
1493 })
1494 }
1495
1496 pub async fn update(
1497 &self,
1498 params: &DocCaptionsUpdateBoundParams,
1499 ) -> Result<DocCaptionsUpdateResult> {
1500 self.update_with_options(params, InvokeOptions::default())
1501 .await
1502 }
1503 pub async fn update_with_options(
1504 &self,
1505 params: &DocCaptionsUpdateBoundParams,
1506 options: InvokeOptions,
1507 ) -> Result<DocCaptionsUpdateResult> {
1508 let params = serde_json::to_value(params)
1509 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1510 let result = self
1511 .invoker
1512 .invoke("doc.captions.update", params, options)
1513 .await?;
1514 serde_json::from_value(result).map_err(|decode| {
1515 let mut error = Error::decode(decode);
1516 error.operation_id = Some("doc.captions.update".to_owned());
1517 error.outcome_unknown = true;
1518 error
1519 })
1520 }
1521}
1522
1523pub struct DocApiCitations<'a, I: Invoker> {
1524 invoker: &'a I,
1525}
1526impl<'a, I: Invoker> DocApiCitations<'a, I> {
1527 pub fn new(invoker: &'a I) -> Self {
1528 Self { invoker }
1529 }
1530 pub fn bibliography(&self) -> DocApiCitationsBibliography<'a, I> {
1531 DocApiCitationsBibliography::new(self.invoker)
1532 }
1533 pub fn sources(&self) -> DocApiCitationsSources<'a, I> {
1534 DocApiCitationsSources::new(self.invoker)
1535 }
1536
1537 pub async fn get(&self, params: &DocCitationsGetBoundParams) -> Result<DocCitationsGetResult> {
1538 self.get_with_options(params, InvokeOptions::default())
1539 .await
1540 }
1541 pub async fn get_with_options(
1542 &self,
1543 params: &DocCitationsGetBoundParams,
1544 options: InvokeOptions,
1545 ) -> Result<DocCitationsGetResult> {
1546 let params = serde_json::to_value(params)
1547 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1548 let result = self
1549 .invoker
1550 .invoke("doc.citations.get", params, options)
1551 .await?;
1552 serde_json::from_value(result).map_err(|decode| {
1553 let mut error = Error::decode(decode);
1554 error.operation_id = Some("doc.citations.get".to_owned());
1555 error.outcome_unknown = false;
1556 error
1557 })
1558 }
1559
1560 pub async fn insert(
1561 &self,
1562 params: &DocCitationsInsertBoundParams,
1563 ) -> Result<DocCitationsInsertResult> {
1564 self.insert_with_options(params, InvokeOptions::default())
1565 .await
1566 }
1567 pub async fn insert_with_options(
1568 &self,
1569 params: &DocCitationsInsertBoundParams,
1570 options: InvokeOptions,
1571 ) -> Result<DocCitationsInsertResult> {
1572 let params = serde_json::to_value(params)
1573 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1574 let result = self
1575 .invoker
1576 .invoke("doc.citations.insert", params, options)
1577 .await?;
1578 serde_json::from_value(result).map_err(|decode| {
1579 let mut error = Error::decode(decode);
1580 error.operation_id = Some("doc.citations.insert".to_owned());
1581 error.outcome_unknown = true;
1582 error
1583 })
1584 }
1585
1586 pub async fn list(
1587 &self,
1588 params: &DocCitationsListBoundParams,
1589 ) -> Result<DocCitationsListResult> {
1590 self.list_with_options(params, InvokeOptions::default())
1591 .await
1592 }
1593 pub async fn list_with_options(
1594 &self,
1595 params: &DocCitationsListBoundParams,
1596 options: InvokeOptions,
1597 ) -> Result<DocCitationsListResult> {
1598 let params = serde_json::to_value(params)
1599 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1600 let result = self
1601 .invoker
1602 .invoke("doc.citations.list", params, options)
1603 .await?;
1604 serde_json::from_value(result).map_err(|decode| {
1605 let mut error = Error::decode(decode);
1606 error.operation_id = Some("doc.citations.list".to_owned());
1607 error.outcome_unknown = false;
1608 error
1609 })
1610 }
1611
1612 pub async fn remove(
1613 &self,
1614 params: &DocCitationsRemoveBoundParams,
1615 ) -> Result<DocCitationsRemoveResult> {
1616 self.remove_with_options(params, InvokeOptions::default())
1617 .await
1618 }
1619 pub async fn remove_with_options(
1620 &self,
1621 params: &DocCitationsRemoveBoundParams,
1622 options: InvokeOptions,
1623 ) -> Result<DocCitationsRemoveResult> {
1624 let params = serde_json::to_value(params)
1625 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1626 let result = self
1627 .invoker
1628 .invoke("doc.citations.remove", params, options)
1629 .await?;
1630 serde_json::from_value(result).map_err(|decode| {
1631 let mut error = Error::decode(decode);
1632 error.operation_id = Some("doc.citations.remove".to_owned());
1633 error.outcome_unknown = true;
1634 error
1635 })
1636 }
1637
1638 pub async fn update(
1639 &self,
1640 params: &DocCitationsUpdateBoundParams,
1641 ) -> Result<DocCitationsUpdateResult> {
1642 self.update_with_options(params, InvokeOptions::default())
1643 .await
1644 }
1645 pub async fn update_with_options(
1646 &self,
1647 params: &DocCitationsUpdateBoundParams,
1648 options: InvokeOptions,
1649 ) -> Result<DocCitationsUpdateResult> {
1650 let params = serde_json::to_value(params)
1651 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1652 let result = self
1653 .invoker
1654 .invoke("doc.citations.update", params, options)
1655 .await?;
1656 serde_json::from_value(result).map_err(|decode| {
1657 let mut error = Error::decode(decode);
1658 error.operation_id = Some("doc.citations.update".to_owned());
1659 error.outcome_unknown = true;
1660 error
1661 })
1662 }
1663}
1664
1665pub struct DocApiCitationsBibliography<'a, I: Invoker> {
1666 invoker: &'a I,
1667}
1668impl<'a, I: Invoker> DocApiCitationsBibliography<'a, I> {
1669 pub fn new(invoker: &'a I) -> Self {
1670 Self { invoker }
1671 }
1672
1673 pub async fn configure(
1674 &self,
1675 params: &DocCitationsBibliographyConfigureBoundParams,
1676 ) -> Result<DocCitationsBibliographyConfigureResult> {
1677 self.configure_with_options(params, InvokeOptions::default())
1678 .await
1679 }
1680 pub async fn configure_with_options(
1681 &self,
1682 params: &DocCitationsBibliographyConfigureBoundParams,
1683 options: InvokeOptions,
1684 ) -> Result<DocCitationsBibliographyConfigureResult> {
1685 let params = serde_json::to_value(params)
1686 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1687 let result = self
1688 .invoker
1689 .invoke("doc.citations.bibliography.configure", params, options)
1690 .await?;
1691 serde_json::from_value(result).map_err(|decode| {
1692 let mut error = Error::decode(decode);
1693 error.operation_id = Some("doc.citations.bibliography.configure".to_owned());
1694 error.outcome_unknown = true;
1695 error
1696 })
1697 }
1698
1699 pub async fn get(
1700 &self,
1701 params: &DocCitationsBibliographyGetBoundParams,
1702 ) -> Result<DocCitationsBibliographyGetResult> {
1703 self.get_with_options(params, InvokeOptions::default())
1704 .await
1705 }
1706 pub async fn get_with_options(
1707 &self,
1708 params: &DocCitationsBibliographyGetBoundParams,
1709 options: InvokeOptions,
1710 ) -> Result<DocCitationsBibliographyGetResult> {
1711 let params = serde_json::to_value(params)
1712 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1713 let result = self
1714 .invoker
1715 .invoke("doc.citations.bibliography.get", params, options)
1716 .await?;
1717 serde_json::from_value(result).map_err(|decode| {
1718 let mut error = Error::decode(decode);
1719 error.operation_id = Some("doc.citations.bibliography.get".to_owned());
1720 error.outcome_unknown = false;
1721 error
1722 })
1723 }
1724
1725 pub async fn insert(
1726 &self,
1727 params: &DocCitationsBibliographyInsertBoundParams,
1728 ) -> Result<DocCitationsBibliographyInsertResult> {
1729 self.insert_with_options(params, InvokeOptions::default())
1730 .await
1731 }
1732 pub async fn insert_with_options(
1733 &self,
1734 params: &DocCitationsBibliographyInsertBoundParams,
1735 options: InvokeOptions,
1736 ) -> Result<DocCitationsBibliographyInsertResult> {
1737 let params = serde_json::to_value(params)
1738 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1739 let result = self
1740 .invoker
1741 .invoke("doc.citations.bibliography.insert", params, options)
1742 .await?;
1743 serde_json::from_value(result).map_err(|decode| {
1744 let mut error = Error::decode(decode);
1745 error.operation_id = Some("doc.citations.bibliography.insert".to_owned());
1746 error.outcome_unknown = true;
1747 error
1748 })
1749 }
1750
1751 pub async fn rebuild(
1752 &self,
1753 params: &DocCitationsBibliographyRebuildBoundParams,
1754 ) -> Result<DocCitationsBibliographyRebuildResult> {
1755 self.rebuild_with_options(params, InvokeOptions::default())
1756 .await
1757 }
1758 pub async fn rebuild_with_options(
1759 &self,
1760 params: &DocCitationsBibliographyRebuildBoundParams,
1761 options: InvokeOptions,
1762 ) -> Result<DocCitationsBibliographyRebuildResult> {
1763 let params = serde_json::to_value(params)
1764 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1765 let result = self
1766 .invoker
1767 .invoke("doc.citations.bibliography.rebuild", params, options)
1768 .await?;
1769 serde_json::from_value(result).map_err(|decode| {
1770 let mut error = Error::decode(decode);
1771 error.operation_id = Some("doc.citations.bibliography.rebuild".to_owned());
1772 error.outcome_unknown = true;
1773 error
1774 })
1775 }
1776
1777 pub async fn remove(
1778 &self,
1779 params: &DocCitationsBibliographyRemoveBoundParams,
1780 ) -> Result<DocCitationsBibliographyRemoveResult> {
1781 self.remove_with_options(params, InvokeOptions::default())
1782 .await
1783 }
1784 pub async fn remove_with_options(
1785 &self,
1786 params: &DocCitationsBibliographyRemoveBoundParams,
1787 options: InvokeOptions,
1788 ) -> Result<DocCitationsBibliographyRemoveResult> {
1789 let params = serde_json::to_value(params)
1790 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1791 let result = self
1792 .invoker
1793 .invoke("doc.citations.bibliography.remove", params, options)
1794 .await?;
1795 serde_json::from_value(result).map_err(|decode| {
1796 let mut error = Error::decode(decode);
1797 error.operation_id = Some("doc.citations.bibliography.remove".to_owned());
1798 error.outcome_unknown = true;
1799 error
1800 })
1801 }
1802}
1803
1804pub struct DocApiCitationsSources<'a, I: Invoker> {
1805 invoker: &'a I,
1806}
1807impl<'a, I: Invoker> DocApiCitationsSources<'a, I> {
1808 pub fn new(invoker: &'a I) -> Self {
1809 Self { invoker }
1810 }
1811
1812 pub async fn get(
1813 &self,
1814 params: &DocCitationsSourcesGetBoundParams,
1815 ) -> Result<DocCitationsSourcesGetResult> {
1816 self.get_with_options(params, InvokeOptions::default())
1817 .await
1818 }
1819 pub async fn get_with_options(
1820 &self,
1821 params: &DocCitationsSourcesGetBoundParams,
1822 options: InvokeOptions,
1823 ) -> Result<DocCitationsSourcesGetResult> {
1824 let params = serde_json::to_value(params)
1825 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1826 let result = self
1827 .invoker
1828 .invoke("doc.citations.sources.get", params, options)
1829 .await?;
1830 serde_json::from_value(result).map_err(|decode| {
1831 let mut error = Error::decode(decode);
1832 error.operation_id = Some("doc.citations.sources.get".to_owned());
1833 error.outcome_unknown = false;
1834 error
1835 })
1836 }
1837
1838 pub async fn insert(
1839 &self,
1840 params: &DocCitationsSourcesInsertBoundParams,
1841 ) -> Result<DocCitationsSourcesInsertResult> {
1842 self.insert_with_options(params, InvokeOptions::default())
1843 .await
1844 }
1845 pub async fn insert_with_options(
1846 &self,
1847 params: &DocCitationsSourcesInsertBoundParams,
1848 options: InvokeOptions,
1849 ) -> Result<DocCitationsSourcesInsertResult> {
1850 let params = serde_json::to_value(params)
1851 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1852 let result = self
1853 .invoker
1854 .invoke("doc.citations.sources.insert", params, options)
1855 .await?;
1856 serde_json::from_value(result).map_err(|decode| {
1857 let mut error = Error::decode(decode);
1858 error.operation_id = Some("doc.citations.sources.insert".to_owned());
1859 error.outcome_unknown = true;
1860 error
1861 })
1862 }
1863
1864 pub async fn list(
1865 &self,
1866 params: &DocCitationsSourcesListBoundParams,
1867 ) -> Result<DocCitationsSourcesListResult> {
1868 self.list_with_options(params, InvokeOptions::default())
1869 .await
1870 }
1871 pub async fn list_with_options(
1872 &self,
1873 params: &DocCitationsSourcesListBoundParams,
1874 options: InvokeOptions,
1875 ) -> Result<DocCitationsSourcesListResult> {
1876 let params = serde_json::to_value(params)
1877 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1878 let result = self
1879 .invoker
1880 .invoke("doc.citations.sources.list", params, options)
1881 .await?;
1882 serde_json::from_value(result).map_err(|decode| {
1883 let mut error = Error::decode(decode);
1884 error.operation_id = Some("doc.citations.sources.list".to_owned());
1885 error.outcome_unknown = false;
1886 error
1887 })
1888 }
1889
1890 pub async fn remove(
1891 &self,
1892 params: &DocCitationsSourcesRemoveBoundParams,
1893 ) -> Result<DocCitationsSourcesRemoveResult> {
1894 self.remove_with_options(params, InvokeOptions::default())
1895 .await
1896 }
1897 pub async fn remove_with_options(
1898 &self,
1899 params: &DocCitationsSourcesRemoveBoundParams,
1900 options: InvokeOptions,
1901 ) -> Result<DocCitationsSourcesRemoveResult> {
1902 let params = serde_json::to_value(params)
1903 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1904 let result = self
1905 .invoker
1906 .invoke("doc.citations.sources.remove", params, options)
1907 .await?;
1908 serde_json::from_value(result).map_err(|decode| {
1909 let mut error = Error::decode(decode);
1910 error.operation_id = Some("doc.citations.sources.remove".to_owned());
1911 error.outcome_unknown = true;
1912 error
1913 })
1914 }
1915
1916 pub async fn update(
1917 &self,
1918 params: &DocCitationsSourcesUpdateBoundParams,
1919 ) -> Result<DocCitationsSourcesUpdateResult> {
1920 self.update_with_options(params, InvokeOptions::default())
1921 .await
1922 }
1923 pub async fn update_with_options(
1924 &self,
1925 params: &DocCitationsSourcesUpdateBoundParams,
1926 options: InvokeOptions,
1927 ) -> Result<DocCitationsSourcesUpdateResult> {
1928 let params = serde_json::to_value(params)
1929 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1930 let result = self
1931 .invoker
1932 .invoke("doc.citations.sources.update", params, options)
1933 .await?;
1934 serde_json::from_value(result).map_err(|decode| {
1935 let mut error = Error::decode(decode);
1936 error.operation_id = Some("doc.citations.sources.update".to_owned());
1937 error.outcome_unknown = true;
1938 error
1939 })
1940 }
1941}
1942
1943pub struct DocApiClipboard<'a, I: Invoker> {
1944 invoker: &'a I,
1945}
1946impl<'a, I: Invoker> DocApiClipboard<'a, I> {
1947 pub fn new(invoker: &'a I) -> Self {
1948 Self { invoker }
1949 }
1950
1951 pub async fn insert(
1952 &self,
1953 params: &DocClipboardInsertBoundParams,
1954 ) -> Result<DocClipboardInsertResult> {
1955 self.insert_with_options(params, InvokeOptions::default())
1956 .await
1957 }
1958 pub async fn insert_with_options(
1959 &self,
1960 params: &DocClipboardInsertBoundParams,
1961 options: InvokeOptions,
1962 ) -> Result<DocClipboardInsertResult> {
1963 let params = serde_json::to_value(params)
1964 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1965 let result = self
1966 .invoker
1967 .invoke("doc.clipboard.insert", params, options)
1968 .await?;
1969 serde_json::from_value(result).map_err(|decode| {
1970 let mut error = Error::decode(decode);
1971 error.operation_id = Some("doc.clipboard.insert".to_owned());
1972 error.outcome_unknown = true;
1973 error
1974 })
1975 }
1976
1977 pub async fn parse(
1978 &self,
1979 params: &DocClipboardParseBoundParams,
1980 ) -> Result<DocClipboardParseResult> {
1981 self.parse_with_options(params, InvokeOptions::default())
1982 .await
1983 }
1984 pub async fn parse_with_options(
1985 &self,
1986 params: &DocClipboardParseBoundParams,
1987 options: InvokeOptions,
1988 ) -> Result<DocClipboardParseResult> {
1989 let params = serde_json::to_value(params)
1990 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
1991 let result = self
1992 .invoker
1993 .invoke("doc.clipboard.parse", params, options)
1994 .await?;
1995 serde_json::from_value(result).map_err(|decode| {
1996 let mut error = Error::decode(decode);
1997 error.operation_id = Some("doc.clipboard.parse".to_owned());
1998 error.outcome_unknown = false;
1999 error
2000 })
2001 }
2002
2003 pub async fn serialize_selection(
2004 &self,
2005 params: &DocClipboardSerializeSelectionBoundParams,
2006 ) -> Result<DocClipboardSerializeSelectionResult> {
2007 self.serialize_selection_with_options(params, InvokeOptions::default())
2008 .await
2009 }
2010 pub async fn serialize_selection_with_options(
2011 &self,
2012 params: &DocClipboardSerializeSelectionBoundParams,
2013 options: InvokeOptions,
2014 ) -> Result<DocClipboardSerializeSelectionResult> {
2015 let params = serde_json::to_value(params)
2016 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2017 let result = self
2018 .invoker
2019 .invoke("doc.clipboard.serializeSelection", params, options)
2020 .await?;
2021 serde_json::from_value(result).map_err(|decode| {
2022 let mut error = Error::decode(decode);
2023 error.operation_id = Some("doc.clipboard.serializeSelection".to_owned());
2024 error.outcome_unknown = false;
2025 error
2026 })
2027 }
2028}
2029
2030pub struct DocApiComments<'a, I: Invoker> {
2031 invoker: &'a I,
2032}
2033impl<'a, I: Invoker> DocApiComments<'a, I> {
2034 pub fn new(invoker: &'a I) -> Self {
2035 Self { invoker }
2036 }
2037
2038 pub async fn create(
2039 &self,
2040 params: &DocCommentsCreateBoundParams,
2041 ) -> Result<DocCommentsCreateResult> {
2042 self.create_with_options(params, InvokeOptions::default())
2043 .await
2044 }
2045 pub async fn create_with_options(
2046 &self,
2047 params: &DocCommentsCreateBoundParams,
2048 options: InvokeOptions,
2049 ) -> Result<DocCommentsCreateResult> {
2050 let params = serde_json::to_value(params)
2051 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2052 let result = self
2053 .invoker
2054 .invoke("doc.comments.create", params, options)
2055 .await?;
2056 serde_json::from_value(result).map_err(|decode| {
2057 let mut error = Error::decode(decode);
2058 error.operation_id = Some("doc.comments.create".to_owned());
2059 error.outcome_unknown = true;
2060 error
2061 })
2062 }
2063
2064 pub async fn delete(
2065 &self,
2066 params: &DocCommentsDeleteBoundParams,
2067 ) -> Result<DocCommentsDeleteResult> {
2068 self.delete_with_options(params, InvokeOptions::default())
2069 .await
2070 }
2071 pub async fn delete_with_options(
2072 &self,
2073 params: &DocCommentsDeleteBoundParams,
2074 options: InvokeOptions,
2075 ) -> Result<DocCommentsDeleteResult> {
2076 let params = serde_json::to_value(params)
2077 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2078 let result = self
2079 .invoker
2080 .invoke("doc.comments.delete", params, options)
2081 .await?;
2082 serde_json::from_value(result).map_err(|decode| {
2083 let mut error = Error::decode(decode);
2084 error.operation_id = Some("doc.comments.delete".to_owned());
2085 error.outcome_unknown = true;
2086 error
2087 })
2088 }
2089
2090 pub async fn get(&self, params: &DocCommentsGetBoundParams) -> Result<DocCommentsGetResult> {
2091 self.get_with_options(params, InvokeOptions::default())
2092 .await
2093 }
2094 pub async fn get_with_options(
2095 &self,
2096 params: &DocCommentsGetBoundParams,
2097 options: InvokeOptions,
2098 ) -> Result<DocCommentsGetResult> {
2099 let params = serde_json::to_value(params)
2100 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2101 let result = self
2102 .invoker
2103 .invoke("doc.comments.get", params, options)
2104 .await?;
2105 serde_json::from_value(result).map_err(|decode| {
2106 let mut error = Error::decode(decode);
2107 error.operation_id = Some("doc.comments.get".to_owned());
2108 error.outcome_unknown = false;
2109 error
2110 })
2111 }
2112
2113 pub async fn list(&self, params: &DocCommentsListBoundParams) -> Result<DocCommentsListResult> {
2114 self.list_with_options(params, InvokeOptions::default())
2115 .await
2116 }
2117 pub async fn list_with_options(
2118 &self,
2119 params: &DocCommentsListBoundParams,
2120 options: InvokeOptions,
2121 ) -> Result<DocCommentsListResult> {
2122 let params = serde_json::to_value(params)
2123 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2124 let result = self
2125 .invoker
2126 .invoke("doc.comments.list", params, options)
2127 .await?;
2128 serde_json::from_value(result).map_err(|decode| {
2129 let mut error = Error::decode(decode);
2130 error.operation_id = Some("doc.comments.list".to_owned());
2131 error.outcome_unknown = false;
2132 error
2133 })
2134 }
2135
2136 pub async fn patch(
2137 &self,
2138 params: &DocCommentsPatchBoundParams,
2139 ) -> Result<DocCommentsPatchResult> {
2140 self.patch_with_options(params, InvokeOptions::default())
2141 .await
2142 }
2143 pub async fn patch_with_options(
2144 &self,
2145 params: &DocCommentsPatchBoundParams,
2146 options: InvokeOptions,
2147 ) -> Result<DocCommentsPatchResult> {
2148 let params = serde_json::to_value(params)
2149 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2150 let result = self
2151 .invoker
2152 .invoke("doc.comments.patch", params, options)
2153 .await?;
2154 serde_json::from_value(result).map_err(|decode| {
2155 let mut error = Error::decode(decode);
2156 error.operation_id = Some("doc.comments.patch".to_owned());
2157 error.outcome_unknown = true;
2158 error
2159 })
2160 }
2161}
2162
2163pub struct DocApiContentControls<'a, I: Invoker> {
2164 invoker: &'a I,
2165}
2166impl<'a, I: Invoker> DocApiContentControls<'a, I> {
2167 pub fn new(invoker: &'a I) -> Self {
2168 Self { invoker }
2169 }
2170 pub fn checkbox(&self) -> DocApiContentControlsCheckbox<'a, I> {
2171 DocApiContentControlsCheckbox::new(self.invoker)
2172 }
2173 pub fn choice_list(&self) -> DocApiContentControlsChoiceList<'a, I> {
2174 DocApiContentControlsChoiceList::new(self.invoker)
2175 }
2176 pub fn date(&self) -> DocApiContentControlsDate<'a, I> {
2177 DocApiContentControlsDate::new(self.invoker)
2178 }
2179 pub fn group(&self) -> DocApiContentControlsGroup<'a, I> {
2180 DocApiContentControlsGroup::new(self.invoker)
2181 }
2182 pub fn repeating_section(&self) -> DocApiContentControlsRepeatingSection<'a, I> {
2183 DocApiContentControlsRepeatingSection::new(self.invoker)
2184 }
2185 pub fn text(&self) -> DocApiContentControlsText<'a, I> {
2186 DocApiContentControlsText::new(self.invoker)
2187 }
2188
2189 pub async fn append_content(
2190 &self,
2191 params: &DocContentControlsAppendContentBoundParams,
2192 ) -> Result<DocContentControlsAppendContentResult> {
2193 self.append_content_with_options(params, InvokeOptions::default())
2194 .await
2195 }
2196 pub async fn append_content_with_options(
2197 &self,
2198 params: &DocContentControlsAppendContentBoundParams,
2199 options: InvokeOptions,
2200 ) -> Result<DocContentControlsAppendContentResult> {
2201 let params = serde_json::to_value(params)
2202 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2203 let result = self
2204 .invoker
2205 .invoke("doc.contentControls.appendContent", params, options)
2206 .await?;
2207 serde_json::from_value(result).map_err(|decode| {
2208 let mut error = Error::decode(decode);
2209 error.operation_id = Some("doc.contentControls.appendContent".to_owned());
2210 error.outcome_unknown = true;
2211 error
2212 })
2213 }
2214
2215 pub async fn clear_binding(
2216 &self,
2217 params: &DocContentControlsClearBindingBoundParams,
2218 ) -> Result<DocContentControlsClearBindingResult> {
2219 self.clear_binding_with_options(params, InvokeOptions::default())
2220 .await
2221 }
2222 pub async fn clear_binding_with_options(
2223 &self,
2224 params: &DocContentControlsClearBindingBoundParams,
2225 options: InvokeOptions,
2226 ) -> Result<DocContentControlsClearBindingResult> {
2227 let params = serde_json::to_value(params)
2228 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2229 let result = self
2230 .invoker
2231 .invoke("doc.contentControls.clearBinding", params, options)
2232 .await?;
2233 serde_json::from_value(result).map_err(|decode| {
2234 let mut error = Error::decode(decode);
2235 error.operation_id = Some("doc.contentControls.clearBinding".to_owned());
2236 error.outcome_unknown = true;
2237 error
2238 })
2239 }
2240
2241 pub async fn clear_content(
2242 &self,
2243 params: &DocContentControlsClearContentBoundParams,
2244 ) -> Result<DocContentControlsClearContentResult> {
2245 self.clear_content_with_options(params, InvokeOptions::default())
2246 .await
2247 }
2248 pub async fn clear_content_with_options(
2249 &self,
2250 params: &DocContentControlsClearContentBoundParams,
2251 options: InvokeOptions,
2252 ) -> Result<DocContentControlsClearContentResult> {
2253 let params = serde_json::to_value(params)
2254 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2255 let result = self
2256 .invoker
2257 .invoke("doc.contentControls.clearContent", params, options)
2258 .await?;
2259 serde_json::from_value(result).map_err(|decode| {
2260 let mut error = Error::decode(decode);
2261 error.operation_id = Some("doc.contentControls.clearContent".to_owned());
2262 error.outcome_unknown = true;
2263 error
2264 })
2265 }
2266
2267 pub async fn copy(
2268 &self,
2269 params: &DocContentControlsCopyBoundParams,
2270 ) -> Result<DocContentControlsCopyResult> {
2271 self.copy_with_options(params, InvokeOptions::default())
2272 .await
2273 }
2274 pub async fn copy_with_options(
2275 &self,
2276 params: &DocContentControlsCopyBoundParams,
2277 options: InvokeOptions,
2278 ) -> Result<DocContentControlsCopyResult> {
2279 let params = serde_json::to_value(params)
2280 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2281 let result = self
2282 .invoker
2283 .invoke("doc.contentControls.copy", params, options)
2284 .await?;
2285 serde_json::from_value(result).map_err(|decode| {
2286 let mut error = Error::decode(decode);
2287 error.operation_id = Some("doc.contentControls.copy".to_owned());
2288 error.outcome_unknown = true;
2289 error
2290 })
2291 }
2292
2293 pub async fn delete(
2294 &self,
2295 params: &DocContentControlsDeleteBoundParams,
2296 ) -> Result<DocContentControlsDeleteResult> {
2297 self.delete_with_options(params, InvokeOptions::default())
2298 .await
2299 }
2300 pub async fn delete_with_options(
2301 &self,
2302 params: &DocContentControlsDeleteBoundParams,
2303 options: InvokeOptions,
2304 ) -> Result<DocContentControlsDeleteResult> {
2305 let params = serde_json::to_value(params)
2306 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2307 let result = self
2308 .invoker
2309 .invoke("doc.contentControls.delete", params, options)
2310 .await?;
2311 serde_json::from_value(result).map_err(|decode| {
2312 let mut error = Error::decode(decode);
2313 error.operation_id = Some("doc.contentControls.delete".to_owned());
2314 error.outcome_unknown = true;
2315 error
2316 })
2317 }
2318
2319 pub async fn get(
2320 &self,
2321 params: &DocContentControlsGetBoundParams,
2322 ) -> Result<DocContentControlsGetResult> {
2323 self.get_with_options(params, InvokeOptions::default())
2324 .await
2325 }
2326 pub async fn get_with_options(
2327 &self,
2328 params: &DocContentControlsGetBoundParams,
2329 options: InvokeOptions,
2330 ) -> Result<DocContentControlsGetResult> {
2331 let params = serde_json::to_value(params)
2332 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2333 let result = self
2334 .invoker
2335 .invoke("doc.contentControls.get", params, options)
2336 .await?;
2337 serde_json::from_value(result).map_err(|decode| {
2338 let mut error = Error::decode(decode);
2339 error.operation_id = Some("doc.contentControls.get".to_owned());
2340 error.outcome_unknown = false;
2341 error
2342 })
2343 }
2344
2345 pub async fn get_binding(
2346 &self,
2347 params: &DocContentControlsGetBindingBoundParams,
2348 ) -> Result<DocContentControlsGetBindingResult> {
2349 self.get_binding_with_options(params, InvokeOptions::default())
2350 .await
2351 }
2352 pub async fn get_binding_with_options(
2353 &self,
2354 params: &DocContentControlsGetBindingBoundParams,
2355 options: InvokeOptions,
2356 ) -> Result<DocContentControlsGetBindingResult> {
2357 let params = serde_json::to_value(params)
2358 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2359 let result = self
2360 .invoker
2361 .invoke("doc.contentControls.getBinding", params, options)
2362 .await?;
2363 serde_json::from_value(result).map_err(|decode| {
2364 let mut error = Error::decode(decode);
2365 error.operation_id = Some("doc.contentControls.getBinding".to_owned());
2366 error.outcome_unknown = false;
2367 error
2368 })
2369 }
2370
2371 pub async fn get_content(
2372 &self,
2373 params: &DocContentControlsGetContentBoundParams,
2374 ) -> Result<DocContentControlsGetContentResult> {
2375 self.get_content_with_options(params, InvokeOptions::default())
2376 .await
2377 }
2378 pub async fn get_content_with_options(
2379 &self,
2380 params: &DocContentControlsGetContentBoundParams,
2381 options: InvokeOptions,
2382 ) -> Result<DocContentControlsGetContentResult> {
2383 let params = serde_json::to_value(params)
2384 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2385 let result = self
2386 .invoker
2387 .invoke("doc.contentControls.getContent", params, options)
2388 .await?;
2389 serde_json::from_value(result).map_err(|decode| {
2390 let mut error = Error::decode(decode);
2391 error.operation_id = Some("doc.contentControls.getContent".to_owned());
2392 error.outcome_unknown = false;
2393 error
2394 })
2395 }
2396
2397 pub async fn get_parent(
2398 &self,
2399 params: &DocContentControlsGetParentBoundParams,
2400 ) -> Result<DocContentControlsGetParentResult> {
2401 self.get_parent_with_options(params, InvokeOptions::default())
2402 .await
2403 }
2404 pub async fn get_parent_with_options(
2405 &self,
2406 params: &DocContentControlsGetParentBoundParams,
2407 options: InvokeOptions,
2408 ) -> Result<DocContentControlsGetParentResult> {
2409 let params = serde_json::to_value(params)
2410 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2411 let result = self
2412 .invoker
2413 .invoke("doc.contentControls.getParent", params, options)
2414 .await?;
2415 serde_json::from_value(result).map_err(|decode| {
2416 let mut error = Error::decode(decode);
2417 error.operation_id = Some("doc.contentControls.getParent".to_owned());
2418 error.outcome_unknown = false;
2419 error
2420 })
2421 }
2422
2423 pub async fn get_raw_properties(
2424 &self,
2425 params: &DocContentControlsGetRawPropertiesBoundParams,
2426 ) -> Result<DocContentControlsGetRawPropertiesResult> {
2427 self.get_raw_properties_with_options(params, InvokeOptions::default())
2428 .await
2429 }
2430 pub async fn get_raw_properties_with_options(
2431 &self,
2432 params: &DocContentControlsGetRawPropertiesBoundParams,
2433 options: InvokeOptions,
2434 ) -> Result<DocContentControlsGetRawPropertiesResult> {
2435 let params = serde_json::to_value(params)
2436 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2437 let result = self
2438 .invoker
2439 .invoke("doc.contentControls.getRawProperties", params, options)
2440 .await?;
2441 serde_json::from_value(result).map_err(|decode| {
2442 let mut error = Error::decode(decode);
2443 error.operation_id = Some("doc.contentControls.getRawProperties".to_owned());
2444 error.outcome_unknown = false;
2445 error
2446 })
2447 }
2448
2449 pub async fn insert_after(
2450 &self,
2451 params: &DocContentControlsInsertAfterBoundParams,
2452 ) -> Result<DocContentControlsInsertAfterResult> {
2453 self.insert_after_with_options(params, InvokeOptions::default())
2454 .await
2455 }
2456 pub async fn insert_after_with_options(
2457 &self,
2458 params: &DocContentControlsInsertAfterBoundParams,
2459 options: InvokeOptions,
2460 ) -> Result<DocContentControlsInsertAfterResult> {
2461 let params = serde_json::to_value(params)
2462 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2463 let result = self
2464 .invoker
2465 .invoke("doc.contentControls.insertAfter", params, options)
2466 .await?;
2467 serde_json::from_value(result).map_err(|decode| {
2468 let mut error = Error::decode(decode);
2469 error.operation_id = Some("doc.contentControls.insertAfter".to_owned());
2470 error.outcome_unknown = true;
2471 error
2472 })
2473 }
2474
2475 pub async fn insert_before(
2476 &self,
2477 params: &DocContentControlsInsertBeforeBoundParams,
2478 ) -> Result<DocContentControlsInsertBeforeResult> {
2479 self.insert_before_with_options(params, InvokeOptions::default())
2480 .await
2481 }
2482 pub async fn insert_before_with_options(
2483 &self,
2484 params: &DocContentControlsInsertBeforeBoundParams,
2485 options: InvokeOptions,
2486 ) -> Result<DocContentControlsInsertBeforeResult> {
2487 let params = serde_json::to_value(params)
2488 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2489 let result = self
2490 .invoker
2491 .invoke("doc.contentControls.insertBefore", params, options)
2492 .await?;
2493 serde_json::from_value(result).map_err(|decode| {
2494 let mut error = Error::decode(decode);
2495 error.operation_id = Some("doc.contentControls.insertBefore".to_owned());
2496 error.outcome_unknown = true;
2497 error
2498 })
2499 }
2500
2501 pub async fn list(
2502 &self,
2503 params: &DocContentControlsListBoundParams,
2504 ) -> Result<DocContentControlsListResult> {
2505 self.list_with_options(params, InvokeOptions::default())
2506 .await
2507 }
2508 pub async fn list_with_options(
2509 &self,
2510 params: &DocContentControlsListBoundParams,
2511 options: InvokeOptions,
2512 ) -> Result<DocContentControlsListResult> {
2513 let params = serde_json::to_value(params)
2514 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2515 let result = self
2516 .invoker
2517 .invoke("doc.contentControls.list", params, options)
2518 .await?;
2519 serde_json::from_value(result).map_err(|decode| {
2520 let mut error = Error::decode(decode);
2521 error.operation_id = Some("doc.contentControls.list".to_owned());
2522 error.outcome_unknown = false;
2523 error
2524 })
2525 }
2526
2527 pub async fn list_children(
2528 &self,
2529 params: &DocContentControlsListChildrenBoundParams,
2530 ) -> Result<DocContentControlsListChildrenResult> {
2531 self.list_children_with_options(params, InvokeOptions::default())
2532 .await
2533 }
2534 pub async fn list_children_with_options(
2535 &self,
2536 params: &DocContentControlsListChildrenBoundParams,
2537 options: InvokeOptions,
2538 ) -> Result<DocContentControlsListChildrenResult> {
2539 let params = serde_json::to_value(params)
2540 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2541 let result = self
2542 .invoker
2543 .invoke("doc.contentControls.listChildren", params, options)
2544 .await?;
2545 serde_json::from_value(result).map_err(|decode| {
2546 let mut error = Error::decode(decode);
2547 error.operation_id = Some("doc.contentControls.listChildren".to_owned());
2548 error.outcome_unknown = false;
2549 error
2550 })
2551 }
2552
2553 pub async fn list_in_range(
2554 &self,
2555 params: &DocContentControlsListInRangeBoundParams,
2556 ) -> Result<DocContentControlsListInRangeResult> {
2557 self.list_in_range_with_options(params, InvokeOptions::default())
2558 .await
2559 }
2560 pub async fn list_in_range_with_options(
2561 &self,
2562 params: &DocContentControlsListInRangeBoundParams,
2563 options: InvokeOptions,
2564 ) -> Result<DocContentControlsListInRangeResult> {
2565 let params = serde_json::to_value(params)
2566 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2567 let result = self
2568 .invoker
2569 .invoke("doc.contentControls.listInRange", params, options)
2570 .await?;
2571 serde_json::from_value(result).map_err(|decode| {
2572 let mut error = Error::decode(decode);
2573 error.operation_id = Some("doc.contentControls.listInRange".to_owned());
2574 error.outcome_unknown = false;
2575 error
2576 })
2577 }
2578
2579 pub async fn move_(
2580 &self,
2581 params: &DocContentControlsMoveBoundParams,
2582 ) -> Result<DocContentControlsMoveResult> {
2583 self.move_with_options(params, InvokeOptions::default())
2584 .await
2585 }
2586 pub async fn move_with_options(
2587 &self,
2588 params: &DocContentControlsMoveBoundParams,
2589 options: InvokeOptions,
2590 ) -> Result<DocContentControlsMoveResult> {
2591 let params = serde_json::to_value(params)
2592 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2593 let result = self
2594 .invoker
2595 .invoke("doc.contentControls.move", params, options)
2596 .await?;
2597 serde_json::from_value(result).map_err(|decode| {
2598 let mut error = Error::decode(decode);
2599 error.operation_id = Some("doc.contentControls.move".to_owned());
2600 error.outcome_unknown = true;
2601 error
2602 })
2603 }
2604
2605 pub async fn normalize_tag_payload(
2606 &self,
2607 params: &DocContentControlsNormalizeTagPayloadBoundParams,
2608 ) -> Result<DocContentControlsNormalizeTagPayloadResult> {
2609 self.normalize_tag_payload_with_options(params, InvokeOptions::default())
2610 .await
2611 }
2612 pub async fn normalize_tag_payload_with_options(
2613 &self,
2614 params: &DocContentControlsNormalizeTagPayloadBoundParams,
2615 options: InvokeOptions,
2616 ) -> Result<DocContentControlsNormalizeTagPayloadResult> {
2617 let params = serde_json::to_value(params)
2618 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2619 let result = self
2620 .invoker
2621 .invoke("doc.contentControls.normalizeTagPayload", params, options)
2622 .await?;
2623 serde_json::from_value(result).map_err(|decode| {
2624 let mut error = Error::decode(decode);
2625 error.operation_id = Some("doc.contentControls.normalizeTagPayload".to_owned());
2626 error.outcome_unknown = true;
2627 error
2628 })
2629 }
2630
2631 pub async fn normalize_word_compatibility(
2632 &self,
2633 params: &DocContentControlsNormalizeWordCompatibilityBoundParams,
2634 ) -> Result<DocContentControlsNormalizeWordCompatibilityResult> {
2635 self.normalize_word_compatibility_with_options(params, InvokeOptions::default())
2636 .await
2637 }
2638 pub async fn normalize_word_compatibility_with_options(
2639 &self,
2640 params: &DocContentControlsNormalizeWordCompatibilityBoundParams,
2641 options: InvokeOptions,
2642 ) -> Result<DocContentControlsNormalizeWordCompatibilityResult> {
2643 let params = serde_json::to_value(params)
2644 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2645 let result = self
2646 .invoker
2647 .invoke(
2648 "doc.contentControls.normalizeWordCompatibility",
2649 params,
2650 options,
2651 )
2652 .await?;
2653 serde_json::from_value(result).map_err(|decode| {
2654 let mut error = Error::decode(decode);
2655 error.operation_id = Some("doc.contentControls.normalizeWordCompatibility".to_owned());
2656 error.outcome_unknown = true;
2657 error
2658 })
2659 }
2660
2661 pub async fn patch(
2662 &self,
2663 params: &DocContentControlsPatchBoundParams,
2664 ) -> Result<DocContentControlsPatchResult> {
2665 self.patch_with_options(params, InvokeOptions::default())
2666 .await
2667 }
2668 pub async fn patch_with_options(
2669 &self,
2670 params: &DocContentControlsPatchBoundParams,
2671 options: InvokeOptions,
2672 ) -> Result<DocContentControlsPatchResult> {
2673 let params = serde_json::to_value(params)
2674 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2675 let result = self
2676 .invoker
2677 .invoke("doc.contentControls.patch", params, options)
2678 .await?;
2679 serde_json::from_value(result).map_err(|decode| {
2680 let mut error = Error::decode(decode);
2681 error.operation_id = Some("doc.contentControls.patch".to_owned());
2682 error.outcome_unknown = true;
2683 error
2684 })
2685 }
2686
2687 pub async fn patch_raw_properties(
2688 &self,
2689 params: &DocContentControlsPatchRawPropertiesBoundParams,
2690 ) -> Result<DocContentControlsPatchRawPropertiesResult> {
2691 self.patch_raw_properties_with_options(params, InvokeOptions::default())
2692 .await
2693 }
2694 pub async fn patch_raw_properties_with_options(
2695 &self,
2696 params: &DocContentControlsPatchRawPropertiesBoundParams,
2697 options: InvokeOptions,
2698 ) -> Result<DocContentControlsPatchRawPropertiesResult> {
2699 let params = serde_json::to_value(params)
2700 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2701 let result = self
2702 .invoker
2703 .invoke("doc.contentControls.patchRawProperties", params, options)
2704 .await?;
2705 serde_json::from_value(result).map_err(|decode| {
2706 let mut error = Error::decode(decode);
2707 error.operation_id = Some("doc.contentControls.patchRawProperties".to_owned());
2708 error.outcome_unknown = true;
2709 error
2710 })
2711 }
2712
2713 pub async fn prepend_content(
2714 &self,
2715 params: &DocContentControlsPrependContentBoundParams,
2716 ) -> Result<DocContentControlsPrependContentResult> {
2717 self.prepend_content_with_options(params, InvokeOptions::default())
2718 .await
2719 }
2720 pub async fn prepend_content_with_options(
2721 &self,
2722 params: &DocContentControlsPrependContentBoundParams,
2723 options: InvokeOptions,
2724 ) -> Result<DocContentControlsPrependContentResult> {
2725 let params = serde_json::to_value(params)
2726 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2727 let result = self
2728 .invoker
2729 .invoke("doc.contentControls.prependContent", params, options)
2730 .await?;
2731 serde_json::from_value(result).map_err(|decode| {
2732 let mut error = Error::decode(decode);
2733 error.operation_id = Some("doc.contentControls.prependContent".to_owned());
2734 error.outcome_unknown = true;
2735 error
2736 })
2737 }
2738
2739 pub async fn replace_content(
2740 &self,
2741 params: &DocContentControlsReplaceContentBoundParams,
2742 ) -> Result<DocContentControlsReplaceContentResult> {
2743 self.replace_content_with_options(params, InvokeOptions::default())
2744 .await
2745 }
2746 pub async fn replace_content_with_options(
2747 &self,
2748 params: &DocContentControlsReplaceContentBoundParams,
2749 options: InvokeOptions,
2750 ) -> Result<DocContentControlsReplaceContentResult> {
2751 let params = serde_json::to_value(params)
2752 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2753 let result = self
2754 .invoker
2755 .invoke("doc.contentControls.replaceContent", params, options)
2756 .await?;
2757 serde_json::from_value(result).map_err(|decode| {
2758 let mut error = Error::decode(decode);
2759 error.operation_id = Some("doc.contentControls.replaceContent".to_owned());
2760 error.outcome_unknown = true;
2761 error
2762 })
2763 }
2764
2765 pub async fn select_by_tag(
2766 &self,
2767 params: &DocContentControlsSelectByTagBoundParams,
2768 ) -> Result<DocContentControlsSelectByTagResult> {
2769 self.select_by_tag_with_options(params, InvokeOptions::default())
2770 .await
2771 }
2772 pub async fn select_by_tag_with_options(
2773 &self,
2774 params: &DocContentControlsSelectByTagBoundParams,
2775 options: InvokeOptions,
2776 ) -> Result<DocContentControlsSelectByTagResult> {
2777 let params = serde_json::to_value(params)
2778 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2779 let result = self
2780 .invoker
2781 .invoke("doc.contentControls.selectByTag", params, options)
2782 .await?;
2783 serde_json::from_value(result).map_err(|decode| {
2784 let mut error = Error::decode(decode);
2785 error.operation_id = Some("doc.contentControls.selectByTag".to_owned());
2786 error.outcome_unknown = false;
2787 error
2788 })
2789 }
2790
2791 pub async fn select_by_title(
2792 &self,
2793 params: &DocContentControlsSelectByTitleBoundParams,
2794 ) -> Result<DocContentControlsSelectByTitleResult> {
2795 self.select_by_title_with_options(params, InvokeOptions::default())
2796 .await
2797 }
2798 pub async fn select_by_title_with_options(
2799 &self,
2800 params: &DocContentControlsSelectByTitleBoundParams,
2801 options: InvokeOptions,
2802 ) -> Result<DocContentControlsSelectByTitleResult> {
2803 let params = serde_json::to_value(params)
2804 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2805 let result = self
2806 .invoker
2807 .invoke("doc.contentControls.selectByTitle", params, options)
2808 .await?;
2809 serde_json::from_value(result).map_err(|decode| {
2810 let mut error = Error::decode(decode);
2811 error.operation_id = Some("doc.contentControls.selectByTitle".to_owned());
2812 error.outcome_unknown = false;
2813 error
2814 })
2815 }
2816
2817 pub async fn set_binding(
2818 &self,
2819 params: &DocContentControlsSetBindingBoundParams,
2820 ) -> Result<DocContentControlsSetBindingResult> {
2821 self.set_binding_with_options(params, InvokeOptions::default())
2822 .await
2823 }
2824 pub async fn set_binding_with_options(
2825 &self,
2826 params: &DocContentControlsSetBindingBoundParams,
2827 options: InvokeOptions,
2828 ) -> Result<DocContentControlsSetBindingResult> {
2829 let params = serde_json::to_value(params)
2830 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2831 let result = self
2832 .invoker
2833 .invoke("doc.contentControls.setBinding", params, options)
2834 .await?;
2835 serde_json::from_value(result).map_err(|decode| {
2836 let mut error = Error::decode(decode);
2837 error.operation_id = Some("doc.contentControls.setBinding".to_owned());
2838 error.outcome_unknown = true;
2839 error
2840 })
2841 }
2842
2843 pub async fn set_lock_mode(
2844 &self,
2845 params: &DocContentControlsSetLockModeBoundParams,
2846 ) -> Result<DocContentControlsSetLockModeResult> {
2847 self.set_lock_mode_with_options(params, InvokeOptions::default())
2848 .await
2849 }
2850 pub async fn set_lock_mode_with_options(
2851 &self,
2852 params: &DocContentControlsSetLockModeBoundParams,
2853 options: InvokeOptions,
2854 ) -> Result<DocContentControlsSetLockModeResult> {
2855 let params = serde_json::to_value(params)
2856 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2857 let result = self
2858 .invoker
2859 .invoke("doc.contentControls.setLockMode", params, options)
2860 .await?;
2861 serde_json::from_value(result).map_err(|decode| {
2862 let mut error = Error::decode(decode);
2863 error.operation_id = Some("doc.contentControls.setLockMode".to_owned());
2864 error.outcome_unknown = true;
2865 error
2866 })
2867 }
2868
2869 pub async fn set_type(
2870 &self,
2871 params: &DocContentControlsSetTypeBoundParams,
2872 ) -> Result<DocContentControlsSetTypeResult> {
2873 self.set_type_with_options(params, InvokeOptions::default())
2874 .await
2875 }
2876 pub async fn set_type_with_options(
2877 &self,
2878 params: &DocContentControlsSetTypeBoundParams,
2879 options: InvokeOptions,
2880 ) -> Result<DocContentControlsSetTypeResult> {
2881 let params = serde_json::to_value(params)
2882 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2883 let result = self
2884 .invoker
2885 .invoke("doc.contentControls.setType", params, options)
2886 .await?;
2887 serde_json::from_value(result).map_err(|decode| {
2888 let mut error = Error::decode(decode);
2889 error.operation_id = Some("doc.contentControls.setType".to_owned());
2890 error.outcome_unknown = true;
2891 error
2892 })
2893 }
2894
2895 pub async fn unwrap(
2896 &self,
2897 params: &DocContentControlsUnwrapBoundParams,
2898 ) -> Result<DocContentControlsUnwrapResult> {
2899 self.unwrap_with_options(params, InvokeOptions::default())
2900 .await
2901 }
2902 pub async fn unwrap_with_options(
2903 &self,
2904 params: &DocContentControlsUnwrapBoundParams,
2905 options: InvokeOptions,
2906 ) -> Result<DocContentControlsUnwrapResult> {
2907 let params = serde_json::to_value(params)
2908 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2909 let result = self
2910 .invoker
2911 .invoke("doc.contentControls.unwrap", params, options)
2912 .await?;
2913 serde_json::from_value(result).map_err(|decode| {
2914 let mut error = Error::decode(decode);
2915 error.operation_id = Some("doc.contentControls.unwrap".to_owned());
2916 error.outcome_unknown = true;
2917 error
2918 })
2919 }
2920
2921 pub async fn validate_word_compatibility(
2922 &self,
2923 params: &DocContentControlsValidateWordCompatibilityBoundParams,
2924 ) -> Result<DocContentControlsValidateWordCompatibilityResult> {
2925 self.validate_word_compatibility_with_options(params, InvokeOptions::default())
2926 .await
2927 }
2928 pub async fn validate_word_compatibility_with_options(
2929 &self,
2930 params: &DocContentControlsValidateWordCompatibilityBoundParams,
2931 options: InvokeOptions,
2932 ) -> Result<DocContentControlsValidateWordCompatibilityResult> {
2933 let params = serde_json::to_value(params)
2934 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2935 let result = self
2936 .invoker
2937 .invoke(
2938 "doc.contentControls.validateWordCompatibility",
2939 params,
2940 options,
2941 )
2942 .await?;
2943 serde_json::from_value(result).map_err(|decode| {
2944 let mut error = Error::decode(decode);
2945 error.operation_id = Some("doc.contentControls.validateWordCompatibility".to_owned());
2946 error.outcome_unknown = false;
2947 error
2948 })
2949 }
2950
2951 pub async fn wrap(
2952 &self,
2953 params: &DocContentControlsWrapBoundParams,
2954 ) -> Result<DocContentControlsWrapResult> {
2955 self.wrap_with_options(params, InvokeOptions::default())
2956 .await
2957 }
2958 pub async fn wrap_with_options(
2959 &self,
2960 params: &DocContentControlsWrapBoundParams,
2961 options: InvokeOptions,
2962 ) -> Result<DocContentControlsWrapResult> {
2963 let params = serde_json::to_value(params)
2964 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
2965 let result = self
2966 .invoker
2967 .invoke("doc.contentControls.wrap", params, options)
2968 .await?;
2969 serde_json::from_value(result).map_err(|decode| {
2970 let mut error = Error::decode(decode);
2971 error.operation_id = Some("doc.contentControls.wrap".to_owned());
2972 error.outcome_unknown = true;
2973 error
2974 })
2975 }
2976}
2977
2978pub struct DocApiContentControlsCheckbox<'a, I: Invoker> {
2979 invoker: &'a I,
2980}
2981impl<'a, I: Invoker> DocApiContentControlsCheckbox<'a, I> {
2982 pub fn new(invoker: &'a I) -> Self {
2983 Self { invoker }
2984 }
2985
2986 pub async fn get_state(
2987 &self,
2988 params: &DocContentControlsCheckboxGetStateBoundParams,
2989 ) -> Result<DocContentControlsCheckboxGetStateResult> {
2990 self.get_state_with_options(params, InvokeOptions::default())
2991 .await
2992 }
2993 pub async fn get_state_with_options(
2994 &self,
2995 params: &DocContentControlsCheckboxGetStateBoundParams,
2996 options: InvokeOptions,
2997 ) -> Result<DocContentControlsCheckboxGetStateResult> {
2998 let params = serde_json::to_value(params)
2999 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3000 let result = self
3001 .invoker
3002 .invoke("doc.contentControls.checkbox.getState", params, options)
3003 .await?;
3004 serde_json::from_value(result).map_err(|decode| {
3005 let mut error = Error::decode(decode);
3006 error.operation_id = Some("doc.contentControls.checkbox.getState".to_owned());
3007 error.outcome_unknown = false;
3008 error
3009 })
3010 }
3011
3012 pub async fn set_state(
3013 &self,
3014 params: &DocContentControlsCheckboxSetStateBoundParams,
3015 ) -> Result<DocContentControlsCheckboxSetStateResult> {
3016 self.set_state_with_options(params, InvokeOptions::default())
3017 .await
3018 }
3019 pub async fn set_state_with_options(
3020 &self,
3021 params: &DocContentControlsCheckboxSetStateBoundParams,
3022 options: InvokeOptions,
3023 ) -> Result<DocContentControlsCheckboxSetStateResult> {
3024 let params = serde_json::to_value(params)
3025 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3026 let result = self
3027 .invoker
3028 .invoke("doc.contentControls.checkbox.setState", params, options)
3029 .await?;
3030 serde_json::from_value(result).map_err(|decode| {
3031 let mut error = Error::decode(decode);
3032 error.operation_id = Some("doc.contentControls.checkbox.setState".to_owned());
3033 error.outcome_unknown = true;
3034 error
3035 })
3036 }
3037
3038 pub async fn set_symbol_pair(
3039 &self,
3040 params: &DocContentControlsCheckboxSetSymbolPairBoundParams,
3041 ) -> Result<DocContentControlsCheckboxSetSymbolPairResult> {
3042 self.set_symbol_pair_with_options(params, InvokeOptions::default())
3043 .await
3044 }
3045 pub async fn set_symbol_pair_with_options(
3046 &self,
3047 params: &DocContentControlsCheckboxSetSymbolPairBoundParams,
3048 options: InvokeOptions,
3049 ) -> Result<DocContentControlsCheckboxSetSymbolPairResult> {
3050 let params = serde_json::to_value(params)
3051 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3052 let result = self
3053 .invoker
3054 .invoke(
3055 "doc.contentControls.checkbox.setSymbolPair",
3056 params,
3057 options,
3058 )
3059 .await?;
3060 serde_json::from_value(result).map_err(|decode| {
3061 let mut error = Error::decode(decode);
3062 error.operation_id = Some("doc.contentControls.checkbox.setSymbolPair".to_owned());
3063 error.outcome_unknown = true;
3064 error
3065 })
3066 }
3067
3068 pub async fn toggle(
3069 &self,
3070 params: &DocContentControlsCheckboxToggleBoundParams,
3071 ) -> Result<DocContentControlsCheckboxToggleResult> {
3072 self.toggle_with_options(params, InvokeOptions::default())
3073 .await
3074 }
3075 pub async fn toggle_with_options(
3076 &self,
3077 params: &DocContentControlsCheckboxToggleBoundParams,
3078 options: InvokeOptions,
3079 ) -> Result<DocContentControlsCheckboxToggleResult> {
3080 let params = serde_json::to_value(params)
3081 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3082 let result = self
3083 .invoker
3084 .invoke("doc.contentControls.checkbox.toggle", params, options)
3085 .await?;
3086 serde_json::from_value(result).map_err(|decode| {
3087 let mut error = Error::decode(decode);
3088 error.operation_id = Some("doc.contentControls.checkbox.toggle".to_owned());
3089 error.outcome_unknown = true;
3090 error
3091 })
3092 }
3093}
3094
3095pub struct DocApiContentControlsChoiceList<'a, I: Invoker> {
3096 invoker: &'a I,
3097}
3098impl<'a, I: Invoker> DocApiContentControlsChoiceList<'a, I> {
3099 pub fn new(invoker: &'a I) -> Self {
3100 Self { invoker }
3101 }
3102
3103 pub async fn get_items(
3104 &self,
3105 params: &DocContentControlsChoiceListGetItemsBoundParams,
3106 ) -> Result<DocContentControlsChoiceListGetItemsResult> {
3107 self.get_items_with_options(params, InvokeOptions::default())
3108 .await
3109 }
3110 pub async fn get_items_with_options(
3111 &self,
3112 params: &DocContentControlsChoiceListGetItemsBoundParams,
3113 options: InvokeOptions,
3114 ) -> Result<DocContentControlsChoiceListGetItemsResult> {
3115 let params = serde_json::to_value(params)
3116 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3117 let result = self
3118 .invoker
3119 .invoke("doc.contentControls.choiceList.getItems", params, options)
3120 .await?;
3121 serde_json::from_value(result).map_err(|decode| {
3122 let mut error = Error::decode(decode);
3123 error.operation_id = Some("doc.contentControls.choiceList.getItems".to_owned());
3124 error.outcome_unknown = false;
3125 error
3126 })
3127 }
3128
3129 pub async fn set_items(
3130 &self,
3131 params: &DocContentControlsChoiceListSetItemsBoundParams,
3132 ) -> Result<DocContentControlsChoiceListSetItemsResult> {
3133 self.set_items_with_options(params, InvokeOptions::default())
3134 .await
3135 }
3136 pub async fn set_items_with_options(
3137 &self,
3138 params: &DocContentControlsChoiceListSetItemsBoundParams,
3139 options: InvokeOptions,
3140 ) -> Result<DocContentControlsChoiceListSetItemsResult> {
3141 let params = serde_json::to_value(params)
3142 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3143 let result = self
3144 .invoker
3145 .invoke("doc.contentControls.choiceList.setItems", params, options)
3146 .await?;
3147 serde_json::from_value(result).map_err(|decode| {
3148 let mut error = Error::decode(decode);
3149 error.operation_id = Some("doc.contentControls.choiceList.setItems".to_owned());
3150 error.outcome_unknown = true;
3151 error
3152 })
3153 }
3154
3155 pub async fn set_selected(
3156 &self,
3157 params: &DocContentControlsChoiceListSetSelectedBoundParams,
3158 ) -> Result<DocContentControlsChoiceListSetSelectedResult> {
3159 self.set_selected_with_options(params, InvokeOptions::default())
3160 .await
3161 }
3162 pub async fn set_selected_with_options(
3163 &self,
3164 params: &DocContentControlsChoiceListSetSelectedBoundParams,
3165 options: InvokeOptions,
3166 ) -> Result<DocContentControlsChoiceListSetSelectedResult> {
3167 let params = serde_json::to_value(params)
3168 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3169 let result = self
3170 .invoker
3171 .invoke(
3172 "doc.contentControls.choiceList.setSelected",
3173 params,
3174 options,
3175 )
3176 .await?;
3177 serde_json::from_value(result).map_err(|decode| {
3178 let mut error = Error::decode(decode);
3179 error.operation_id = Some("doc.contentControls.choiceList.setSelected".to_owned());
3180 error.outcome_unknown = true;
3181 error
3182 })
3183 }
3184}
3185
3186pub struct DocApiContentControlsDate<'a, I: Invoker> {
3187 invoker: &'a I,
3188}
3189impl<'a, I: Invoker> DocApiContentControlsDate<'a, I> {
3190 pub fn new(invoker: &'a I) -> Self {
3191 Self { invoker }
3192 }
3193
3194 pub async fn clear_value(
3195 &self,
3196 params: &DocContentControlsDateClearValueBoundParams,
3197 ) -> Result<DocContentControlsDateClearValueResult> {
3198 self.clear_value_with_options(params, InvokeOptions::default())
3199 .await
3200 }
3201 pub async fn clear_value_with_options(
3202 &self,
3203 params: &DocContentControlsDateClearValueBoundParams,
3204 options: InvokeOptions,
3205 ) -> Result<DocContentControlsDateClearValueResult> {
3206 let params = serde_json::to_value(params)
3207 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3208 let result = self
3209 .invoker
3210 .invoke("doc.contentControls.date.clearValue", params, options)
3211 .await?;
3212 serde_json::from_value(result).map_err(|decode| {
3213 let mut error = Error::decode(decode);
3214 error.operation_id = Some("doc.contentControls.date.clearValue".to_owned());
3215 error.outcome_unknown = true;
3216 error
3217 })
3218 }
3219
3220 pub async fn set_calendar(
3221 &self,
3222 params: &DocContentControlsDateSetCalendarBoundParams,
3223 ) -> Result<DocContentControlsDateSetCalendarResult> {
3224 self.set_calendar_with_options(params, InvokeOptions::default())
3225 .await
3226 }
3227 pub async fn set_calendar_with_options(
3228 &self,
3229 params: &DocContentControlsDateSetCalendarBoundParams,
3230 options: InvokeOptions,
3231 ) -> Result<DocContentControlsDateSetCalendarResult> {
3232 let params = serde_json::to_value(params)
3233 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3234 let result = self
3235 .invoker
3236 .invoke("doc.contentControls.date.setCalendar", params, options)
3237 .await?;
3238 serde_json::from_value(result).map_err(|decode| {
3239 let mut error = Error::decode(decode);
3240 error.operation_id = Some("doc.contentControls.date.setCalendar".to_owned());
3241 error.outcome_unknown = true;
3242 error
3243 })
3244 }
3245
3246 pub async fn set_display_format(
3247 &self,
3248 params: &DocContentControlsDateSetDisplayFormatBoundParams,
3249 ) -> Result<DocContentControlsDateSetDisplayFormatResult> {
3250 self.set_display_format_with_options(params, InvokeOptions::default())
3251 .await
3252 }
3253 pub async fn set_display_format_with_options(
3254 &self,
3255 params: &DocContentControlsDateSetDisplayFormatBoundParams,
3256 options: InvokeOptions,
3257 ) -> Result<DocContentControlsDateSetDisplayFormatResult> {
3258 let params = serde_json::to_value(params)
3259 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3260 let result = self
3261 .invoker
3262 .invoke("doc.contentControls.date.setDisplayFormat", params, options)
3263 .await?;
3264 serde_json::from_value(result).map_err(|decode| {
3265 let mut error = Error::decode(decode);
3266 error.operation_id = Some("doc.contentControls.date.setDisplayFormat".to_owned());
3267 error.outcome_unknown = true;
3268 error
3269 })
3270 }
3271
3272 pub async fn set_display_locale(
3273 &self,
3274 params: &DocContentControlsDateSetDisplayLocaleBoundParams,
3275 ) -> Result<DocContentControlsDateSetDisplayLocaleResult> {
3276 self.set_display_locale_with_options(params, InvokeOptions::default())
3277 .await
3278 }
3279 pub async fn set_display_locale_with_options(
3280 &self,
3281 params: &DocContentControlsDateSetDisplayLocaleBoundParams,
3282 options: InvokeOptions,
3283 ) -> Result<DocContentControlsDateSetDisplayLocaleResult> {
3284 let params = serde_json::to_value(params)
3285 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3286 let result = self
3287 .invoker
3288 .invoke("doc.contentControls.date.setDisplayLocale", params, options)
3289 .await?;
3290 serde_json::from_value(result).map_err(|decode| {
3291 let mut error = Error::decode(decode);
3292 error.operation_id = Some("doc.contentControls.date.setDisplayLocale".to_owned());
3293 error.outcome_unknown = true;
3294 error
3295 })
3296 }
3297
3298 pub async fn set_storage_format(
3299 &self,
3300 params: &DocContentControlsDateSetStorageFormatBoundParams,
3301 ) -> Result<DocContentControlsDateSetStorageFormatResult> {
3302 self.set_storage_format_with_options(params, InvokeOptions::default())
3303 .await
3304 }
3305 pub async fn set_storage_format_with_options(
3306 &self,
3307 params: &DocContentControlsDateSetStorageFormatBoundParams,
3308 options: InvokeOptions,
3309 ) -> Result<DocContentControlsDateSetStorageFormatResult> {
3310 let params = serde_json::to_value(params)
3311 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3312 let result = self
3313 .invoker
3314 .invoke("doc.contentControls.date.setStorageFormat", params, options)
3315 .await?;
3316 serde_json::from_value(result).map_err(|decode| {
3317 let mut error = Error::decode(decode);
3318 error.operation_id = Some("doc.contentControls.date.setStorageFormat".to_owned());
3319 error.outcome_unknown = true;
3320 error
3321 })
3322 }
3323
3324 pub async fn set_value(
3325 &self,
3326 params: &DocContentControlsDateSetValueBoundParams,
3327 ) -> Result<DocContentControlsDateSetValueResult> {
3328 self.set_value_with_options(params, InvokeOptions::default())
3329 .await
3330 }
3331 pub async fn set_value_with_options(
3332 &self,
3333 params: &DocContentControlsDateSetValueBoundParams,
3334 options: InvokeOptions,
3335 ) -> Result<DocContentControlsDateSetValueResult> {
3336 let params = serde_json::to_value(params)
3337 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3338 let result = self
3339 .invoker
3340 .invoke("doc.contentControls.date.setValue", params, options)
3341 .await?;
3342 serde_json::from_value(result).map_err(|decode| {
3343 let mut error = Error::decode(decode);
3344 error.operation_id = Some("doc.contentControls.date.setValue".to_owned());
3345 error.outcome_unknown = true;
3346 error
3347 })
3348 }
3349}
3350
3351pub struct DocApiContentControlsGroup<'a, I: Invoker> {
3352 invoker: &'a I,
3353}
3354impl<'a, I: Invoker> DocApiContentControlsGroup<'a, I> {
3355 pub fn new(invoker: &'a I) -> Self {
3356 Self { invoker }
3357 }
3358
3359 pub async fn ungroup(
3360 &self,
3361 params: &DocContentControlsGroupUngroupBoundParams,
3362 ) -> Result<DocContentControlsGroupUngroupResult> {
3363 self.ungroup_with_options(params, InvokeOptions::default())
3364 .await
3365 }
3366 pub async fn ungroup_with_options(
3367 &self,
3368 params: &DocContentControlsGroupUngroupBoundParams,
3369 options: InvokeOptions,
3370 ) -> Result<DocContentControlsGroupUngroupResult> {
3371 let params = serde_json::to_value(params)
3372 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3373 let result = self
3374 .invoker
3375 .invoke("doc.contentControls.group.ungroup", params, options)
3376 .await?;
3377 serde_json::from_value(result).map_err(|decode| {
3378 let mut error = Error::decode(decode);
3379 error.operation_id = Some("doc.contentControls.group.ungroup".to_owned());
3380 error.outcome_unknown = true;
3381 error
3382 })
3383 }
3384
3385 pub async fn wrap(
3386 &self,
3387 params: &DocContentControlsGroupWrapBoundParams,
3388 ) -> Result<DocContentControlsGroupWrapResult> {
3389 self.wrap_with_options(params, InvokeOptions::default())
3390 .await
3391 }
3392 pub async fn wrap_with_options(
3393 &self,
3394 params: &DocContentControlsGroupWrapBoundParams,
3395 options: InvokeOptions,
3396 ) -> Result<DocContentControlsGroupWrapResult> {
3397 let params = serde_json::to_value(params)
3398 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3399 let result = self
3400 .invoker
3401 .invoke("doc.contentControls.group.wrap", params, options)
3402 .await?;
3403 serde_json::from_value(result).map_err(|decode| {
3404 let mut error = Error::decode(decode);
3405 error.operation_id = Some("doc.contentControls.group.wrap".to_owned());
3406 error.outcome_unknown = true;
3407 error
3408 })
3409 }
3410}
3411
3412pub struct DocApiContentControlsRepeatingSection<'a, I: Invoker> {
3413 invoker: &'a I,
3414}
3415impl<'a, I: Invoker> DocApiContentControlsRepeatingSection<'a, I> {
3416 pub fn new(invoker: &'a I) -> Self {
3417 Self { invoker }
3418 }
3419
3420 pub async fn clone_item(
3421 &self,
3422 params: &DocContentControlsRepeatingSectionCloneItemBoundParams,
3423 ) -> Result<DocContentControlsRepeatingSectionCloneItemResult> {
3424 self.clone_item_with_options(params, InvokeOptions::default())
3425 .await
3426 }
3427 pub async fn clone_item_with_options(
3428 &self,
3429 params: &DocContentControlsRepeatingSectionCloneItemBoundParams,
3430 options: InvokeOptions,
3431 ) -> Result<DocContentControlsRepeatingSectionCloneItemResult> {
3432 let params = serde_json::to_value(params)
3433 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3434 let result = self
3435 .invoker
3436 .invoke(
3437 "doc.contentControls.repeatingSection.cloneItem",
3438 params,
3439 options,
3440 )
3441 .await?;
3442 serde_json::from_value(result).map_err(|decode| {
3443 let mut error = Error::decode(decode);
3444 error.operation_id = Some("doc.contentControls.repeatingSection.cloneItem".to_owned());
3445 error.outcome_unknown = true;
3446 error
3447 })
3448 }
3449
3450 pub async fn delete_item(
3451 &self,
3452 params: &DocContentControlsRepeatingSectionDeleteItemBoundParams,
3453 ) -> Result<DocContentControlsRepeatingSectionDeleteItemResult> {
3454 self.delete_item_with_options(params, InvokeOptions::default())
3455 .await
3456 }
3457 pub async fn delete_item_with_options(
3458 &self,
3459 params: &DocContentControlsRepeatingSectionDeleteItemBoundParams,
3460 options: InvokeOptions,
3461 ) -> Result<DocContentControlsRepeatingSectionDeleteItemResult> {
3462 let params = serde_json::to_value(params)
3463 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3464 let result = self
3465 .invoker
3466 .invoke(
3467 "doc.contentControls.repeatingSection.deleteItem",
3468 params,
3469 options,
3470 )
3471 .await?;
3472 serde_json::from_value(result).map_err(|decode| {
3473 let mut error = Error::decode(decode);
3474 error.operation_id = Some("doc.contentControls.repeatingSection.deleteItem".to_owned());
3475 error.outcome_unknown = true;
3476 error
3477 })
3478 }
3479
3480 pub async fn insert_item_after(
3481 &self,
3482 params: &DocContentControlsRepeatingSectionInsertItemAfterBoundParams,
3483 ) -> Result<DocContentControlsRepeatingSectionInsertItemAfterResult> {
3484 self.insert_item_after_with_options(params, InvokeOptions::default())
3485 .await
3486 }
3487 pub async fn insert_item_after_with_options(
3488 &self,
3489 params: &DocContentControlsRepeatingSectionInsertItemAfterBoundParams,
3490 options: InvokeOptions,
3491 ) -> Result<DocContentControlsRepeatingSectionInsertItemAfterResult> {
3492 let params = serde_json::to_value(params)
3493 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3494 let result = self
3495 .invoker
3496 .invoke(
3497 "doc.contentControls.repeatingSection.insertItemAfter",
3498 params,
3499 options,
3500 )
3501 .await?;
3502 serde_json::from_value(result).map_err(|decode| {
3503 let mut error = Error::decode(decode);
3504 error.operation_id =
3505 Some("doc.contentControls.repeatingSection.insertItemAfter".to_owned());
3506 error.outcome_unknown = true;
3507 error
3508 })
3509 }
3510
3511 pub async fn insert_item_before(
3512 &self,
3513 params: &DocContentControlsRepeatingSectionInsertItemBeforeBoundParams,
3514 ) -> Result<DocContentControlsRepeatingSectionInsertItemBeforeResult> {
3515 self.insert_item_before_with_options(params, InvokeOptions::default())
3516 .await
3517 }
3518 pub async fn insert_item_before_with_options(
3519 &self,
3520 params: &DocContentControlsRepeatingSectionInsertItemBeforeBoundParams,
3521 options: InvokeOptions,
3522 ) -> Result<DocContentControlsRepeatingSectionInsertItemBeforeResult> {
3523 let params = serde_json::to_value(params)
3524 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3525 let result = self
3526 .invoker
3527 .invoke(
3528 "doc.contentControls.repeatingSection.insertItemBefore",
3529 params,
3530 options,
3531 )
3532 .await?;
3533 serde_json::from_value(result).map_err(|decode| {
3534 let mut error = Error::decode(decode);
3535 error.operation_id =
3536 Some("doc.contentControls.repeatingSection.insertItemBefore".to_owned());
3537 error.outcome_unknown = true;
3538 error
3539 })
3540 }
3541
3542 pub async fn list_items(
3543 &self,
3544 params: &DocContentControlsRepeatingSectionListItemsBoundParams,
3545 ) -> Result<DocContentControlsRepeatingSectionListItemsResult> {
3546 self.list_items_with_options(params, InvokeOptions::default())
3547 .await
3548 }
3549 pub async fn list_items_with_options(
3550 &self,
3551 params: &DocContentControlsRepeatingSectionListItemsBoundParams,
3552 options: InvokeOptions,
3553 ) -> Result<DocContentControlsRepeatingSectionListItemsResult> {
3554 let params = serde_json::to_value(params)
3555 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3556 let result = self
3557 .invoker
3558 .invoke(
3559 "doc.contentControls.repeatingSection.listItems",
3560 params,
3561 options,
3562 )
3563 .await?;
3564 serde_json::from_value(result).map_err(|decode| {
3565 let mut error = Error::decode(decode);
3566 error.operation_id = Some("doc.contentControls.repeatingSection.listItems".to_owned());
3567 error.outcome_unknown = false;
3568 error
3569 })
3570 }
3571
3572 pub async fn set_allow_insert_delete(
3573 &self,
3574 params: &DocContentControlsRepeatingSectionSetAllowInsertDeleteBoundParams,
3575 ) -> Result<DocContentControlsRepeatingSectionSetAllowInsertDeleteResult> {
3576 self.set_allow_insert_delete_with_options(params, InvokeOptions::default())
3577 .await
3578 }
3579 pub async fn set_allow_insert_delete_with_options(
3580 &self,
3581 params: &DocContentControlsRepeatingSectionSetAllowInsertDeleteBoundParams,
3582 options: InvokeOptions,
3583 ) -> Result<DocContentControlsRepeatingSectionSetAllowInsertDeleteResult> {
3584 let params = serde_json::to_value(params)
3585 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3586 let result = self
3587 .invoker
3588 .invoke(
3589 "doc.contentControls.repeatingSection.setAllowInsertDelete",
3590 params,
3591 options,
3592 )
3593 .await?;
3594 serde_json::from_value(result).map_err(|decode| {
3595 let mut error = Error::decode(decode);
3596 error.operation_id =
3597 Some("doc.contentControls.repeatingSection.setAllowInsertDelete".to_owned());
3598 error.outcome_unknown = true;
3599 error
3600 })
3601 }
3602}
3603
3604pub struct DocApiContentControlsText<'a, I: Invoker> {
3605 invoker: &'a I,
3606}
3607impl<'a, I: Invoker> DocApiContentControlsText<'a, I> {
3608 pub fn new(invoker: &'a I) -> Self {
3609 Self { invoker }
3610 }
3611
3612 pub async fn clear_value(
3613 &self,
3614 params: &DocContentControlsTextClearValueBoundParams,
3615 ) -> Result<DocContentControlsTextClearValueResult> {
3616 self.clear_value_with_options(params, InvokeOptions::default())
3617 .await
3618 }
3619 pub async fn clear_value_with_options(
3620 &self,
3621 params: &DocContentControlsTextClearValueBoundParams,
3622 options: InvokeOptions,
3623 ) -> Result<DocContentControlsTextClearValueResult> {
3624 let params = serde_json::to_value(params)
3625 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3626 let result = self
3627 .invoker
3628 .invoke("doc.contentControls.text.clearValue", params, options)
3629 .await?;
3630 serde_json::from_value(result).map_err(|decode| {
3631 let mut error = Error::decode(decode);
3632 error.operation_id = Some("doc.contentControls.text.clearValue".to_owned());
3633 error.outcome_unknown = true;
3634 error
3635 })
3636 }
3637
3638 pub async fn set_multiline(
3639 &self,
3640 params: &DocContentControlsTextSetMultilineBoundParams,
3641 ) -> Result<DocContentControlsTextSetMultilineResult> {
3642 self.set_multiline_with_options(params, InvokeOptions::default())
3643 .await
3644 }
3645 pub async fn set_multiline_with_options(
3646 &self,
3647 params: &DocContentControlsTextSetMultilineBoundParams,
3648 options: InvokeOptions,
3649 ) -> Result<DocContentControlsTextSetMultilineResult> {
3650 let params = serde_json::to_value(params)
3651 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3652 let result = self
3653 .invoker
3654 .invoke("doc.contentControls.text.setMultiline", params, options)
3655 .await?;
3656 serde_json::from_value(result).map_err(|decode| {
3657 let mut error = Error::decode(decode);
3658 error.operation_id = Some("doc.contentControls.text.setMultiline".to_owned());
3659 error.outcome_unknown = true;
3660 error
3661 })
3662 }
3663
3664 pub async fn set_value(
3665 &self,
3666 params: &DocContentControlsTextSetValueBoundParams,
3667 ) -> Result<DocContentControlsTextSetValueResult> {
3668 self.set_value_with_options(params, InvokeOptions::default())
3669 .await
3670 }
3671 pub async fn set_value_with_options(
3672 &self,
3673 params: &DocContentControlsTextSetValueBoundParams,
3674 options: InvokeOptions,
3675 ) -> Result<DocContentControlsTextSetValueResult> {
3676 let params = serde_json::to_value(params)
3677 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3678 let result = self
3679 .invoker
3680 .invoke("doc.contentControls.text.setValue", params, options)
3681 .await?;
3682 serde_json::from_value(result).map_err(|decode| {
3683 let mut error = Error::decode(decode);
3684 error.operation_id = Some("doc.contentControls.text.setValue".to_owned());
3685 error.outcome_unknown = true;
3686 error
3687 })
3688 }
3689}
3690
3691pub struct DocApiCreate<'a, I: Invoker> {
3692 invoker: &'a I,
3693}
3694impl<'a, I: Invoker> DocApiCreate<'a, I> {
3695 pub fn new(invoker: &'a I) -> Self {
3696 Self { invoker }
3697 }
3698
3699 pub async fn content_control(
3700 &self,
3701 params: &DocCreateContentControlBoundParams,
3702 ) -> Result<DocCreateContentControlResult> {
3703 self.content_control_with_options(params, InvokeOptions::default())
3704 .await
3705 }
3706 pub async fn content_control_with_options(
3707 &self,
3708 params: &DocCreateContentControlBoundParams,
3709 options: InvokeOptions,
3710 ) -> Result<DocCreateContentControlResult> {
3711 let params = serde_json::to_value(params)
3712 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3713 let result = self
3714 .invoker
3715 .invoke("doc.create.contentControl", params, options)
3716 .await?;
3717 serde_json::from_value(result).map_err(|decode| {
3718 let mut error = Error::decode(decode);
3719 error.operation_id = Some("doc.create.contentControl".to_owned());
3720 error.outcome_unknown = true;
3721 error
3722 })
3723 }
3724
3725 pub async fn heading(
3726 &self,
3727 params: &DocCreateHeadingBoundParams,
3728 ) -> Result<DocCreateHeadingResult> {
3729 self.heading_with_options(params, InvokeOptions::default())
3730 .await
3731 }
3732 pub async fn heading_with_options(
3733 &self,
3734 params: &DocCreateHeadingBoundParams,
3735 options: InvokeOptions,
3736 ) -> Result<DocCreateHeadingResult> {
3737 let params = serde_json::to_value(params)
3738 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3739 let result = self
3740 .invoker
3741 .invoke("doc.create.heading", params, options)
3742 .await?;
3743 serde_json::from_value(result).map_err(|decode| {
3744 let mut error = Error::decode(decode);
3745 error.operation_id = Some("doc.create.heading".to_owned());
3746 error.outcome_unknown = true;
3747 error
3748 })
3749 }
3750
3751 pub async fn image(&self, params: &DocCreateImageBoundParams) -> Result<DocCreateImageResult> {
3752 self.image_with_options(params, InvokeOptions::default())
3753 .await
3754 }
3755 pub async fn image_with_options(
3756 &self,
3757 params: &DocCreateImageBoundParams,
3758 options: InvokeOptions,
3759 ) -> Result<DocCreateImageResult> {
3760 let params = serde_json::to_value(params)
3761 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3762 let result = self
3763 .invoker
3764 .invoke("doc.create.image", params, options)
3765 .await?;
3766 serde_json::from_value(result).map_err(|decode| {
3767 let mut error = Error::decode(decode);
3768 error.operation_id = Some("doc.create.image".to_owned());
3769 error.outcome_unknown = true;
3770 error
3771 })
3772 }
3773
3774 pub async fn paragraph(
3775 &self,
3776 params: &DocCreateParagraphBoundParams,
3777 ) -> Result<DocCreateParagraphResult> {
3778 self.paragraph_with_options(params, InvokeOptions::default())
3779 .await
3780 }
3781 pub async fn paragraph_with_options(
3782 &self,
3783 params: &DocCreateParagraphBoundParams,
3784 options: InvokeOptions,
3785 ) -> Result<DocCreateParagraphResult> {
3786 let params = serde_json::to_value(params)
3787 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3788 let result = self
3789 .invoker
3790 .invoke("doc.create.paragraph", params, options)
3791 .await?;
3792 serde_json::from_value(result).map_err(|decode| {
3793 let mut error = Error::decode(decode);
3794 error.operation_id = Some("doc.create.paragraph".to_owned());
3795 error.outcome_unknown = true;
3796 error
3797 })
3798 }
3799
3800 pub async fn section_break(
3801 &self,
3802 params: &DocCreateSectionBreakBoundParams,
3803 ) -> Result<DocCreateSectionBreakResult> {
3804 self.section_break_with_options(params, InvokeOptions::default())
3805 .await
3806 }
3807 pub async fn section_break_with_options(
3808 &self,
3809 params: &DocCreateSectionBreakBoundParams,
3810 options: InvokeOptions,
3811 ) -> Result<DocCreateSectionBreakResult> {
3812 let params = serde_json::to_value(params)
3813 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3814 let result = self
3815 .invoker
3816 .invoke("doc.create.sectionBreak", params, options)
3817 .await?;
3818 serde_json::from_value(result).map_err(|decode| {
3819 let mut error = Error::decode(decode);
3820 error.operation_id = Some("doc.create.sectionBreak".to_owned());
3821 error.outcome_unknown = true;
3822 error
3823 })
3824 }
3825
3826 pub async fn table(&self, params: &DocCreateTableBoundParams) -> Result<DocCreateTableResult> {
3827 self.table_with_options(params, InvokeOptions::default())
3828 .await
3829 }
3830 pub async fn table_with_options(
3831 &self,
3832 params: &DocCreateTableBoundParams,
3833 options: InvokeOptions,
3834 ) -> Result<DocCreateTableResult> {
3835 let params = serde_json::to_value(params)
3836 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3837 let result = self
3838 .invoker
3839 .invoke("doc.create.table", params, options)
3840 .await?;
3841 serde_json::from_value(result).map_err(|decode| {
3842 let mut error = Error::decode(decode);
3843 error.operation_id = Some("doc.create.table".to_owned());
3844 error.outcome_unknown = true;
3845 error
3846 })
3847 }
3848
3849 pub async fn table_of_contents(
3850 &self,
3851 params: &DocCreateTableOfContentsBoundParams,
3852 ) -> Result<DocCreateTableOfContentsResult> {
3853 self.table_of_contents_with_options(params, InvokeOptions::default())
3854 .await
3855 }
3856 pub async fn table_of_contents_with_options(
3857 &self,
3858 params: &DocCreateTableOfContentsBoundParams,
3859 options: InvokeOptions,
3860 ) -> Result<DocCreateTableOfContentsResult> {
3861 let params = serde_json::to_value(params)
3862 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3863 let result = self
3864 .invoker
3865 .invoke("doc.create.tableOfContents", params, options)
3866 .await?;
3867 serde_json::from_value(result).map_err(|decode| {
3868 let mut error = Error::decode(decode);
3869 error.operation_id = Some("doc.create.tableOfContents".to_owned());
3870 error.outcome_unknown = true;
3871 error
3872 })
3873 }
3874}
3875
3876pub struct DocApiCrossRefs<'a, I: Invoker> {
3877 invoker: &'a I,
3878}
3879impl<'a, I: Invoker> DocApiCrossRefs<'a, I> {
3880 pub fn new(invoker: &'a I) -> Self {
3881 Self { invoker }
3882 }
3883
3884 pub async fn get(&self, params: &DocCrossRefsGetBoundParams) -> Result<DocCrossRefsGetResult> {
3885 self.get_with_options(params, InvokeOptions::default())
3886 .await
3887 }
3888 pub async fn get_with_options(
3889 &self,
3890 params: &DocCrossRefsGetBoundParams,
3891 options: InvokeOptions,
3892 ) -> Result<DocCrossRefsGetResult> {
3893 let params = serde_json::to_value(params)
3894 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3895 let result = self
3896 .invoker
3897 .invoke("doc.crossRefs.get", params, options)
3898 .await?;
3899 serde_json::from_value(result).map_err(|decode| {
3900 let mut error = Error::decode(decode);
3901 error.operation_id = Some("doc.crossRefs.get".to_owned());
3902 error.outcome_unknown = false;
3903 error
3904 })
3905 }
3906
3907 pub async fn insert(
3908 &self,
3909 params: &DocCrossRefsInsertBoundParams,
3910 ) -> Result<DocCrossRefsInsertResult> {
3911 self.insert_with_options(params, InvokeOptions::default())
3912 .await
3913 }
3914 pub async fn insert_with_options(
3915 &self,
3916 params: &DocCrossRefsInsertBoundParams,
3917 options: InvokeOptions,
3918 ) -> Result<DocCrossRefsInsertResult> {
3919 let params = serde_json::to_value(params)
3920 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3921 let result = self
3922 .invoker
3923 .invoke("doc.crossRefs.insert", params, options)
3924 .await?;
3925 serde_json::from_value(result).map_err(|decode| {
3926 let mut error = Error::decode(decode);
3927 error.operation_id = Some("doc.crossRefs.insert".to_owned());
3928 error.outcome_unknown = true;
3929 error
3930 })
3931 }
3932
3933 pub async fn list(
3934 &self,
3935 params: &DocCrossRefsListBoundParams,
3936 ) -> Result<DocCrossRefsListResult> {
3937 self.list_with_options(params, InvokeOptions::default())
3938 .await
3939 }
3940 pub async fn list_with_options(
3941 &self,
3942 params: &DocCrossRefsListBoundParams,
3943 options: InvokeOptions,
3944 ) -> Result<DocCrossRefsListResult> {
3945 let params = serde_json::to_value(params)
3946 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3947 let result = self
3948 .invoker
3949 .invoke("doc.crossRefs.list", params, options)
3950 .await?;
3951 serde_json::from_value(result).map_err(|decode| {
3952 let mut error = Error::decode(decode);
3953 error.operation_id = Some("doc.crossRefs.list".to_owned());
3954 error.outcome_unknown = false;
3955 error
3956 })
3957 }
3958
3959 pub async fn rebuild(
3960 &self,
3961 params: &DocCrossRefsRebuildBoundParams,
3962 ) -> Result<DocCrossRefsRebuildResult> {
3963 self.rebuild_with_options(params, InvokeOptions::default())
3964 .await
3965 }
3966 pub async fn rebuild_with_options(
3967 &self,
3968 params: &DocCrossRefsRebuildBoundParams,
3969 options: InvokeOptions,
3970 ) -> Result<DocCrossRefsRebuildResult> {
3971 let params = serde_json::to_value(params)
3972 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3973 let result = self
3974 .invoker
3975 .invoke("doc.crossRefs.rebuild", params, options)
3976 .await?;
3977 serde_json::from_value(result).map_err(|decode| {
3978 let mut error = Error::decode(decode);
3979 error.operation_id = Some("doc.crossRefs.rebuild".to_owned());
3980 error.outcome_unknown = true;
3981 error
3982 })
3983 }
3984
3985 pub async fn remove(
3986 &self,
3987 params: &DocCrossRefsRemoveBoundParams,
3988 ) -> Result<DocCrossRefsRemoveResult> {
3989 self.remove_with_options(params, InvokeOptions::default())
3990 .await
3991 }
3992 pub async fn remove_with_options(
3993 &self,
3994 params: &DocCrossRefsRemoveBoundParams,
3995 options: InvokeOptions,
3996 ) -> Result<DocCrossRefsRemoveResult> {
3997 let params = serde_json::to_value(params)
3998 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
3999 let result = self
4000 .invoker
4001 .invoke("doc.crossRefs.remove", params, options)
4002 .await?;
4003 serde_json::from_value(result).map_err(|decode| {
4004 let mut error = Error::decode(decode);
4005 error.operation_id = Some("doc.crossRefs.remove".to_owned());
4006 error.outcome_unknown = true;
4007 error
4008 })
4009 }
4010}
4011
4012pub struct DocApiCustomXml<'a, I: Invoker> {
4013 invoker: &'a I,
4014}
4015impl<'a, I: Invoker> DocApiCustomXml<'a, I> {
4016 pub fn new(invoker: &'a I) -> Self {
4017 Self { invoker }
4018 }
4019 pub fn parts(&self) -> DocApiCustomXmlParts<'a, I> {
4020 DocApiCustomXmlParts::new(self.invoker)
4021 }
4022}
4023
4024pub struct DocApiCustomXmlParts<'a, I: Invoker> {
4025 invoker: &'a I,
4026}
4027impl<'a, I: Invoker> DocApiCustomXmlParts<'a, I> {
4028 pub fn new(invoker: &'a I) -> Self {
4029 Self { invoker }
4030 }
4031
4032 pub async fn create(
4033 &self,
4034 params: &DocCustomXmlPartsCreateBoundParams,
4035 ) -> Result<DocCustomXmlPartsCreateResult> {
4036 self.create_with_options(params, InvokeOptions::default())
4037 .await
4038 }
4039 pub async fn create_with_options(
4040 &self,
4041 params: &DocCustomXmlPartsCreateBoundParams,
4042 options: InvokeOptions,
4043 ) -> Result<DocCustomXmlPartsCreateResult> {
4044 let params = serde_json::to_value(params)
4045 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4046 let result = self
4047 .invoker
4048 .invoke("doc.customXml.parts.create", params, options)
4049 .await?;
4050 serde_json::from_value(result).map_err(|decode| {
4051 let mut error = Error::decode(decode);
4052 error.operation_id = Some("doc.customXml.parts.create".to_owned());
4053 error.outcome_unknown = true;
4054 error
4055 })
4056 }
4057
4058 pub async fn get(
4059 &self,
4060 params: &DocCustomXmlPartsGetBoundParams,
4061 ) -> Result<DocCustomXmlPartsGetResult> {
4062 self.get_with_options(params, InvokeOptions::default())
4063 .await
4064 }
4065 pub async fn get_with_options(
4066 &self,
4067 params: &DocCustomXmlPartsGetBoundParams,
4068 options: InvokeOptions,
4069 ) -> Result<DocCustomXmlPartsGetResult> {
4070 let params = serde_json::to_value(params)
4071 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4072 let result = self
4073 .invoker
4074 .invoke("doc.customXml.parts.get", params, options)
4075 .await?;
4076 serde_json::from_value(result).map_err(|decode| {
4077 let mut error = Error::decode(decode);
4078 error.operation_id = Some("doc.customXml.parts.get".to_owned());
4079 error.outcome_unknown = false;
4080 error
4081 })
4082 }
4083
4084 pub async fn list(
4085 &self,
4086 params: &DocCustomXmlPartsListBoundParams,
4087 ) -> Result<DocCustomXmlPartsListResult> {
4088 self.list_with_options(params, InvokeOptions::default())
4089 .await
4090 }
4091 pub async fn list_with_options(
4092 &self,
4093 params: &DocCustomXmlPartsListBoundParams,
4094 options: InvokeOptions,
4095 ) -> Result<DocCustomXmlPartsListResult> {
4096 let params = serde_json::to_value(params)
4097 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4098 let result = self
4099 .invoker
4100 .invoke("doc.customXml.parts.list", params, options)
4101 .await?;
4102 serde_json::from_value(result).map_err(|decode| {
4103 let mut error = Error::decode(decode);
4104 error.operation_id = Some("doc.customXml.parts.list".to_owned());
4105 error.outcome_unknown = false;
4106 error
4107 })
4108 }
4109
4110 pub async fn patch(
4111 &self,
4112 params: &DocCustomXmlPartsPatchBoundParams,
4113 ) -> Result<DocCustomXmlPartsPatchResult> {
4114 self.patch_with_options(params, InvokeOptions::default())
4115 .await
4116 }
4117 pub async fn patch_with_options(
4118 &self,
4119 params: &DocCustomXmlPartsPatchBoundParams,
4120 options: InvokeOptions,
4121 ) -> Result<DocCustomXmlPartsPatchResult> {
4122 let params = serde_json::to_value(params)
4123 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4124 let result = self
4125 .invoker
4126 .invoke("doc.customXml.parts.patch", params, options)
4127 .await?;
4128 serde_json::from_value(result).map_err(|decode| {
4129 let mut error = Error::decode(decode);
4130 error.operation_id = Some("doc.customXml.parts.patch".to_owned());
4131 error.outcome_unknown = true;
4132 error
4133 })
4134 }
4135
4136 pub async fn remove(
4137 &self,
4138 params: &DocCustomXmlPartsRemoveBoundParams,
4139 ) -> Result<DocCustomXmlPartsRemoveResult> {
4140 self.remove_with_options(params, InvokeOptions::default())
4141 .await
4142 }
4143 pub async fn remove_with_options(
4144 &self,
4145 params: &DocCustomXmlPartsRemoveBoundParams,
4146 options: InvokeOptions,
4147 ) -> Result<DocCustomXmlPartsRemoveResult> {
4148 let params = serde_json::to_value(params)
4149 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4150 let result = self
4151 .invoker
4152 .invoke("doc.customXml.parts.remove", params, options)
4153 .await?;
4154 serde_json::from_value(result).map_err(|decode| {
4155 let mut error = Error::decode(decode);
4156 error.operation_id = Some("doc.customXml.parts.remove".to_owned());
4157 error.outcome_unknown = true;
4158 error
4159 })
4160 }
4161}
4162
4163pub struct DocApiDiff<'a, I: Invoker> {
4164 invoker: &'a I,
4165}
4166impl<'a, I: Invoker> DocApiDiff<'a, I> {
4167 pub fn new(invoker: &'a I) -> Self {
4168 Self { invoker }
4169 }
4170
4171 pub async fn apply(&self, params: &DocDiffApplyBoundParams) -> Result<DocDiffApplyResult> {
4172 self.apply_with_options(params, InvokeOptions::default())
4173 .await
4174 }
4175 pub async fn apply_with_options(
4176 &self,
4177 params: &DocDiffApplyBoundParams,
4178 options: InvokeOptions,
4179 ) -> Result<DocDiffApplyResult> {
4180 let params = serde_json::to_value(params)
4181 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4182 let result = self
4183 .invoker
4184 .invoke("doc.diff.apply", params, options)
4185 .await?;
4186 serde_json::from_value(result).map_err(|decode| {
4187 let mut error = Error::decode(decode);
4188 error.operation_id = Some("doc.diff.apply".to_owned());
4189 error.outcome_unknown = true;
4190 error
4191 })
4192 }
4193
4194 pub async fn capture(
4195 &self,
4196 params: &DocDiffCaptureBoundParams,
4197 ) -> Result<DocDiffCaptureResult> {
4198 self.capture_with_options(params, InvokeOptions::default())
4199 .await
4200 }
4201 pub async fn capture_with_options(
4202 &self,
4203 params: &DocDiffCaptureBoundParams,
4204 options: InvokeOptions,
4205 ) -> Result<DocDiffCaptureResult> {
4206 let params = serde_json::to_value(params)
4207 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4208 let result = self
4209 .invoker
4210 .invoke("doc.diff.capture", params, options)
4211 .await?;
4212 serde_json::from_value(result).map_err(|decode| {
4213 let mut error = Error::decode(decode);
4214 error.operation_id = Some("doc.diff.capture".to_owned());
4215 error.outcome_unknown = false;
4216 error
4217 })
4218 }
4219
4220 pub async fn compare(
4221 &self,
4222 params: &DocDiffCompareBoundParams,
4223 ) -> Result<DocDiffCompareResult> {
4224 self.compare_with_options(params, InvokeOptions::default())
4225 .await
4226 }
4227 pub async fn compare_with_options(
4228 &self,
4229 params: &DocDiffCompareBoundParams,
4230 options: InvokeOptions,
4231 ) -> Result<DocDiffCompareResult> {
4232 let params = serde_json::to_value(params)
4233 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4234 let result = self
4235 .invoker
4236 .invoke("doc.diff.compare", params, options)
4237 .await?;
4238 serde_json::from_value(result).map_err(|decode| {
4239 let mut error = Error::decode(decode);
4240 error.operation_id = Some("doc.diff.compare".to_owned());
4241 error.outcome_unknown = false;
4242 error
4243 })
4244 }
4245}
4246
4247pub struct DocApiExport<'a, I: Invoker> {
4248 invoker: &'a I,
4249}
4250impl<'a, I: Invoker> DocApiExport<'a, I> {
4251 pub fn new(invoker: &'a I) -> Self {
4252 Self { invoker }
4253 }
4254
4255 pub async fn to_docx(
4256 &self,
4257 params: &DocExportToDocxBoundParams,
4258 ) -> Result<DocExportToDocxResult> {
4259 self.to_docx_with_options(params, InvokeOptions::default())
4260 .await
4261 }
4262 pub async fn to_docx_with_options(
4263 &self,
4264 params: &DocExportToDocxBoundParams,
4265 options: InvokeOptions,
4266 ) -> Result<DocExportToDocxResult> {
4267 let params = serde_json::to_value(params)
4268 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4269 let result = self
4270 .invoker
4271 .invoke("doc.export.toDocx", params, options)
4272 .await?;
4273 serde_json::from_value(result).map_err(|decode| {
4274 let mut error = Error::decode(decode);
4275 error.operation_id = Some("doc.export.toDocx".to_owned());
4276 error.outcome_unknown = false;
4277 error
4278 })
4279 }
4280}
4281
4282pub struct DocApiFields<'a, I: Invoker> {
4283 invoker: &'a I,
4284}
4285impl<'a, I: Invoker> DocApiFields<'a, I> {
4286 pub fn new(invoker: &'a I) -> Self {
4287 Self { invoker }
4288 }
4289
4290 pub async fn get(&self, params: &DocFieldsGetBoundParams) -> Result<DocFieldsGetResult> {
4291 self.get_with_options(params, InvokeOptions::default())
4292 .await
4293 }
4294 pub async fn get_with_options(
4295 &self,
4296 params: &DocFieldsGetBoundParams,
4297 options: InvokeOptions,
4298 ) -> Result<DocFieldsGetResult> {
4299 let params = serde_json::to_value(params)
4300 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4301 let result = self
4302 .invoker
4303 .invoke("doc.fields.get", params, options)
4304 .await?;
4305 serde_json::from_value(result).map_err(|decode| {
4306 let mut error = Error::decode(decode);
4307 error.operation_id = Some("doc.fields.get".to_owned());
4308 error.outcome_unknown = false;
4309 error
4310 })
4311 }
4312
4313 pub async fn insert(
4314 &self,
4315 params: &DocFieldsInsertBoundParams,
4316 ) -> Result<DocFieldsInsertResult> {
4317 self.insert_with_options(params, InvokeOptions::default())
4318 .await
4319 }
4320 pub async fn insert_with_options(
4321 &self,
4322 params: &DocFieldsInsertBoundParams,
4323 options: InvokeOptions,
4324 ) -> Result<DocFieldsInsertResult> {
4325 let params = serde_json::to_value(params)
4326 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4327 let result = self
4328 .invoker
4329 .invoke("doc.fields.insert", params, options)
4330 .await?;
4331 serde_json::from_value(result).map_err(|decode| {
4332 let mut error = Error::decode(decode);
4333 error.operation_id = Some("doc.fields.insert".to_owned());
4334 error.outcome_unknown = true;
4335 error
4336 })
4337 }
4338
4339 pub async fn list(&self, params: &DocFieldsListBoundParams) -> Result<DocFieldsListResult> {
4340 self.list_with_options(params, InvokeOptions::default())
4341 .await
4342 }
4343 pub async fn list_with_options(
4344 &self,
4345 params: &DocFieldsListBoundParams,
4346 options: InvokeOptions,
4347 ) -> Result<DocFieldsListResult> {
4348 let params = serde_json::to_value(params)
4349 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4350 let result = self
4351 .invoker
4352 .invoke("doc.fields.list", params, options)
4353 .await?;
4354 serde_json::from_value(result).map_err(|decode| {
4355 let mut error = Error::decode(decode);
4356 error.operation_id = Some("doc.fields.list".to_owned());
4357 error.outcome_unknown = false;
4358 error
4359 })
4360 }
4361
4362 pub async fn rebuild(
4363 &self,
4364 params: &DocFieldsRebuildBoundParams,
4365 ) -> Result<DocFieldsRebuildResult> {
4366 self.rebuild_with_options(params, InvokeOptions::default())
4367 .await
4368 }
4369 pub async fn rebuild_with_options(
4370 &self,
4371 params: &DocFieldsRebuildBoundParams,
4372 options: InvokeOptions,
4373 ) -> Result<DocFieldsRebuildResult> {
4374 let params = serde_json::to_value(params)
4375 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4376 let result = self
4377 .invoker
4378 .invoke("doc.fields.rebuild", params, options)
4379 .await?;
4380 serde_json::from_value(result).map_err(|decode| {
4381 let mut error = Error::decode(decode);
4382 error.operation_id = Some("doc.fields.rebuild".to_owned());
4383 error.outcome_unknown = true;
4384 error
4385 })
4386 }
4387
4388 pub async fn remove(
4389 &self,
4390 params: &DocFieldsRemoveBoundParams,
4391 ) -> Result<DocFieldsRemoveResult> {
4392 self.remove_with_options(params, InvokeOptions::default())
4393 .await
4394 }
4395 pub async fn remove_with_options(
4396 &self,
4397 params: &DocFieldsRemoveBoundParams,
4398 options: InvokeOptions,
4399 ) -> Result<DocFieldsRemoveResult> {
4400 let params = serde_json::to_value(params)
4401 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4402 let result = self
4403 .invoker
4404 .invoke("doc.fields.remove", params, options)
4405 .await?;
4406 serde_json::from_value(result).map_err(|decode| {
4407 let mut error = Error::decode(decode);
4408 error.operation_id = Some("doc.fields.remove".to_owned());
4409 error.outcome_unknown = true;
4410 error
4411 })
4412 }
4413}
4414
4415pub struct DocApiFootnotes<'a, I: Invoker> {
4416 invoker: &'a I,
4417}
4418impl<'a, I: Invoker> DocApiFootnotes<'a, I> {
4419 pub fn new(invoker: &'a I) -> Self {
4420 Self { invoker }
4421 }
4422
4423 pub async fn configure(
4424 &self,
4425 params: &DocFootnotesConfigureBoundParams,
4426 ) -> Result<DocFootnotesConfigureResult> {
4427 self.configure_with_options(params, InvokeOptions::default())
4428 .await
4429 }
4430 pub async fn configure_with_options(
4431 &self,
4432 params: &DocFootnotesConfigureBoundParams,
4433 options: InvokeOptions,
4434 ) -> Result<DocFootnotesConfigureResult> {
4435 let params = serde_json::to_value(params)
4436 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4437 let result = self
4438 .invoker
4439 .invoke("doc.footnotes.configure", params, options)
4440 .await?;
4441 serde_json::from_value(result).map_err(|decode| {
4442 let mut error = Error::decode(decode);
4443 error.operation_id = Some("doc.footnotes.configure".to_owned());
4444 error.outcome_unknown = true;
4445 error
4446 })
4447 }
4448
4449 pub async fn get(&self, params: &DocFootnotesGetBoundParams) -> Result<DocFootnotesGetResult> {
4450 self.get_with_options(params, InvokeOptions::default())
4451 .await
4452 }
4453 pub async fn get_with_options(
4454 &self,
4455 params: &DocFootnotesGetBoundParams,
4456 options: InvokeOptions,
4457 ) -> Result<DocFootnotesGetResult> {
4458 let params = serde_json::to_value(params)
4459 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4460 let result = self
4461 .invoker
4462 .invoke("doc.footnotes.get", params, options)
4463 .await?;
4464 serde_json::from_value(result).map_err(|decode| {
4465 let mut error = Error::decode(decode);
4466 error.operation_id = Some("doc.footnotes.get".to_owned());
4467 error.outcome_unknown = false;
4468 error
4469 })
4470 }
4471
4472 pub async fn insert(
4473 &self,
4474 params: &DocFootnotesInsertBoundParams,
4475 ) -> Result<DocFootnotesInsertResult> {
4476 self.insert_with_options(params, InvokeOptions::default())
4477 .await
4478 }
4479 pub async fn insert_with_options(
4480 &self,
4481 params: &DocFootnotesInsertBoundParams,
4482 options: InvokeOptions,
4483 ) -> Result<DocFootnotesInsertResult> {
4484 let params = serde_json::to_value(params)
4485 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4486 let result = self
4487 .invoker
4488 .invoke("doc.footnotes.insert", params, options)
4489 .await?;
4490 serde_json::from_value(result).map_err(|decode| {
4491 let mut error = Error::decode(decode);
4492 error.operation_id = Some("doc.footnotes.insert".to_owned());
4493 error.outcome_unknown = true;
4494 error
4495 })
4496 }
4497
4498 pub async fn list(
4499 &self,
4500 params: &DocFootnotesListBoundParams,
4501 ) -> Result<DocFootnotesListResult> {
4502 self.list_with_options(params, InvokeOptions::default())
4503 .await
4504 }
4505 pub async fn list_with_options(
4506 &self,
4507 params: &DocFootnotesListBoundParams,
4508 options: InvokeOptions,
4509 ) -> Result<DocFootnotesListResult> {
4510 let params = serde_json::to_value(params)
4511 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4512 let result = self
4513 .invoker
4514 .invoke("doc.footnotes.list", params, options)
4515 .await?;
4516 serde_json::from_value(result).map_err(|decode| {
4517 let mut error = Error::decode(decode);
4518 error.operation_id = Some("doc.footnotes.list".to_owned());
4519 error.outcome_unknown = false;
4520 error
4521 })
4522 }
4523
4524 pub async fn remove(
4525 &self,
4526 params: &DocFootnotesRemoveBoundParams,
4527 ) -> Result<DocFootnotesRemoveResult> {
4528 self.remove_with_options(params, InvokeOptions::default())
4529 .await
4530 }
4531 pub async fn remove_with_options(
4532 &self,
4533 params: &DocFootnotesRemoveBoundParams,
4534 options: InvokeOptions,
4535 ) -> Result<DocFootnotesRemoveResult> {
4536 let params = serde_json::to_value(params)
4537 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4538 let result = self
4539 .invoker
4540 .invoke("doc.footnotes.remove", params, options)
4541 .await?;
4542 serde_json::from_value(result).map_err(|decode| {
4543 let mut error = Error::decode(decode);
4544 error.operation_id = Some("doc.footnotes.remove".to_owned());
4545 error.outcome_unknown = true;
4546 error
4547 })
4548 }
4549
4550 pub async fn update(
4551 &self,
4552 params: &DocFootnotesUpdateBoundParams,
4553 ) -> Result<DocFootnotesUpdateResult> {
4554 self.update_with_options(params, InvokeOptions::default())
4555 .await
4556 }
4557 pub async fn update_with_options(
4558 &self,
4559 params: &DocFootnotesUpdateBoundParams,
4560 options: InvokeOptions,
4561 ) -> Result<DocFootnotesUpdateResult> {
4562 let params = serde_json::to_value(params)
4563 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4564 let result = self
4565 .invoker
4566 .invoke("doc.footnotes.update", params, options)
4567 .await?;
4568 serde_json::from_value(result).map_err(|decode| {
4569 let mut error = Error::decode(decode);
4570 error.operation_id = Some("doc.footnotes.update".to_owned());
4571 error.outcome_unknown = true;
4572 error
4573 })
4574 }
4575}
4576
4577pub struct DocApiFormat<'a, I: Invoker> {
4578 invoker: &'a I,
4579}
4580impl<'a, I: Invoker> DocApiFormat<'a, I> {
4581 pub fn new(invoker: &'a I) -> Self {
4582 Self { invoker }
4583 }
4584 pub fn paragraph(&self) -> DocApiFormatParagraph<'a, I> {
4585 DocApiFormatParagraph::new(self.invoker)
4586 }
4587
4588 pub async fn apply(&self, params: &DocFormatApplyBoundParams) -> Result<DocFormatApplyResult> {
4589 self.apply_with_options(params, InvokeOptions::default())
4590 .await
4591 }
4592 pub async fn apply_with_options(
4593 &self,
4594 params: &DocFormatApplyBoundParams,
4595 options: InvokeOptions,
4596 ) -> Result<DocFormatApplyResult> {
4597 let params = serde_json::to_value(params)
4598 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4599 let result = self
4600 .invoker
4601 .invoke("doc.format.apply", params, options)
4602 .await?;
4603 serde_json::from_value(result).map_err(|decode| {
4604 let mut error = Error::decode(decode);
4605 error.operation_id = Some("doc.format.apply".to_owned());
4606 error.outcome_unknown = true;
4607 error
4608 })
4609 }
4610
4611 pub async fn b_cs(&self, params: &DocFormatBCsBoundParams) -> Result<DocFormatBCsResult> {
4612 self.b_cs_with_options(params, InvokeOptions::default())
4613 .await
4614 }
4615 pub async fn b_cs_with_options(
4616 &self,
4617 params: &DocFormatBCsBoundParams,
4618 options: InvokeOptions,
4619 ) -> Result<DocFormatBCsResult> {
4620 let params = serde_json::to_value(params)
4621 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4622 let result = self
4623 .invoker
4624 .invoke("doc.format.bCs", params, options)
4625 .await?;
4626 serde_json::from_value(result).map_err(|decode| {
4627 let mut error = Error::decode(decode);
4628 error.operation_id = Some("doc.format.bCs".to_owned());
4629 error.outcome_unknown = true;
4630 error
4631 })
4632 }
4633
4634 pub async fn bold(&self, params: &DocFormatBoldBoundParams) -> Result<DocFormatBoldResult> {
4635 self.bold_with_options(params, InvokeOptions::default())
4636 .await
4637 }
4638 pub async fn bold_with_options(
4639 &self,
4640 params: &DocFormatBoldBoundParams,
4641 options: InvokeOptions,
4642 ) -> Result<DocFormatBoldResult> {
4643 let params = serde_json::to_value(params)
4644 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4645 let result = self
4646 .invoker
4647 .invoke("doc.format.bold", params, options)
4648 .await?;
4649 serde_json::from_value(result).map_err(|decode| {
4650 let mut error = Error::decode(decode);
4651 error.operation_id = Some("doc.format.bold".to_owned());
4652 error.outcome_unknown = true;
4653 error
4654 })
4655 }
4656
4657 pub async fn border(
4658 &self,
4659 params: &DocFormatBorderBoundParams,
4660 ) -> Result<DocFormatBorderResult> {
4661 self.border_with_options(params, InvokeOptions::default())
4662 .await
4663 }
4664 pub async fn border_with_options(
4665 &self,
4666 params: &DocFormatBorderBoundParams,
4667 options: InvokeOptions,
4668 ) -> Result<DocFormatBorderResult> {
4669 let params = serde_json::to_value(params)
4670 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4671 let result = self
4672 .invoker
4673 .invoke("doc.format.border", params, options)
4674 .await?;
4675 serde_json::from_value(result).map_err(|decode| {
4676 let mut error = Error::decode(decode);
4677 error.operation_id = Some("doc.format.border".to_owned());
4678 error.outcome_unknown = true;
4679 error
4680 })
4681 }
4682
4683 pub async fn caps(&self, params: &DocFormatCapsBoundParams) -> Result<DocFormatCapsResult> {
4684 self.caps_with_options(params, InvokeOptions::default())
4685 .await
4686 }
4687 pub async fn caps_with_options(
4688 &self,
4689 params: &DocFormatCapsBoundParams,
4690 options: InvokeOptions,
4691 ) -> Result<DocFormatCapsResult> {
4692 let params = serde_json::to_value(params)
4693 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4694 let result = self
4695 .invoker
4696 .invoke("doc.format.caps", params, options)
4697 .await?;
4698 serde_json::from_value(result).map_err(|decode| {
4699 let mut error = Error::decode(decode);
4700 error.operation_id = Some("doc.format.caps".to_owned());
4701 error.outcome_unknown = true;
4702 error
4703 })
4704 }
4705
4706 pub async fn char_scale(
4707 &self,
4708 params: &DocFormatCharScaleBoundParams,
4709 ) -> Result<DocFormatCharScaleResult> {
4710 self.char_scale_with_options(params, InvokeOptions::default())
4711 .await
4712 }
4713 pub async fn char_scale_with_options(
4714 &self,
4715 params: &DocFormatCharScaleBoundParams,
4716 options: InvokeOptions,
4717 ) -> Result<DocFormatCharScaleResult> {
4718 let params = serde_json::to_value(params)
4719 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4720 let result = self
4721 .invoker
4722 .invoke("doc.format.charScale", params, options)
4723 .await?;
4724 serde_json::from_value(result).map_err(|decode| {
4725 let mut error = Error::decode(decode);
4726 error.operation_id = Some("doc.format.charScale".to_owned());
4727 error.outcome_unknown = true;
4728 error
4729 })
4730 }
4731
4732 pub async fn color(&self, params: &DocFormatColorBoundParams) -> Result<DocFormatColorResult> {
4733 self.color_with_options(params, InvokeOptions::default())
4734 .await
4735 }
4736 pub async fn color_with_options(
4737 &self,
4738 params: &DocFormatColorBoundParams,
4739 options: InvokeOptions,
4740 ) -> Result<DocFormatColorResult> {
4741 let params = serde_json::to_value(params)
4742 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4743 let result = self
4744 .invoker
4745 .invoke("doc.format.color", params, options)
4746 .await?;
4747 serde_json::from_value(result).map_err(|decode| {
4748 let mut error = Error::decode(decode);
4749 error.operation_id = Some("doc.format.color".to_owned());
4750 error.outcome_unknown = true;
4751 error
4752 })
4753 }
4754
4755 pub async fn contextual_alternates(
4756 &self,
4757 params: &DocFormatContextualAlternatesBoundParams,
4758 ) -> Result<DocFormatContextualAlternatesResult> {
4759 self.contextual_alternates_with_options(params, InvokeOptions::default())
4760 .await
4761 }
4762 pub async fn contextual_alternates_with_options(
4763 &self,
4764 params: &DocFormatContextualAlternatesBoundParams,
4765 options: InvokeOptions,
4766 ) -> Result<DocFormatContextualAlternatesResult> {
4767 let params = serde_json::to_value(params)
4768 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4769 let result = self
4770 .invoker
4771 .invoke("doc.format.contextualAlternates", params, options)
4772 .await?;
4773 serde_json::from_value(result).map_err(|decode| {
4774 let mut error = Error::decode(decode);
4775 error.operation_id = Some("doc.format.contextualAlternates".to_owned());
4776 error.outcome_unknown = true;
4777 error
4778 })
4779 }
4780
4781 pub async fn cs(&self, params: &DocFormatCsBoundParams) -> Result<DocFormatCsResult> {
4782 self.cs_with_options(params, InvokeOptions::default()).await
4783 }
4784 pub async fn cs_with_options(
4785 &self,
4786 params: &DocFormatCsBoundParams,
4787 options: InvokeOptions,
4788 ) -> Result<DocFormatCsResult> {
4789 let params = serde_json::to_value(params)
4790 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4791 let result = self
4792 .invoker
4793 .invoke("doc.format.cs", params, options)
4794 .await?;
4795 serde_json::from_value(result).map_err(|decode| {
4796 let mut error = Error::decode(decode);
4797 error.operation_id = Some("doc.format.cs".to_owned());
4798 error.outcome_unknown = true;
4799 error
4800 })
4801 }
4802
4803 pub async fn dstrike(
4804 &self,
4805 params: &DocFormatDstrikeBoundParams,
4806 ) -> Result<DocFormatDstrikeResult> {
4807 self.dstrike_with_options(params, InvokeOptions::default())
4808 .await
4809 }
4810 pub async fn dstrike_with_options(
4811 &self,
4812 params: &DocFormatDstrikeBoundParams,
4813 options: InvokeOptions,
4814 ) -> Result<DocFormatDstrikeResult> {
4815 let params = serde_json::to_value(params)
4816 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4817 let result = self
4818 .invoker
4819 .invoke("doc.format.dstrike", params, options)
4820 .await?;
4821 serde_json::from_value(result).map_err(|decode| {
4822 let mut error = Error::decode(decode);
4823 error.operation_id = Some("doc.format.dstrike".to_owned());
4824 error.outcome_unknown = true;
4825 error
4826 })
4827 }
4828
4829 pub async fn east_asian_layout(
4830 &self,
4831 params: &DocFormatEastAsianLayoutBoundParams,
4832 ) -> Result<DocFormatEastAsianLayoutResult> {
4833 self.east_asian_layout_with_options(params, InvokeOptions::default())
4834 .await
4835 }
4836 pub async fn east_asian_layout_with_options(
4837 &self,
4838 params: &DocFormatEastAsianLayoutBoundParams,
4839 options: InvokeOptions,
4840 ) -> Result<DocFormatEastAsianLayoutResult> {
4841 let params = serde_json::to_value(params)
4842 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4843 let result = self
4844 .invoker
4845 .invoke("doc.format.eastAsianLayout", params, options)
4846 .await?;
4847 serde_json::from_value(result).map_err(|decode| {
4848 let mut error = Error::decode(decode);
4849 error.operation_id = Some("doc.format.eastAsianLayout".to_owned());
4850 error.outcome_unknown = true;
4851 error
4852 })
4853 }
4854
4855 pub async fn em(&self, params: &DocFormatEmBoundParams) -> Result<DocFormatEmResult> {
4856 self.em_with_options(params, InvokeOptions::default()).await
4857 }
4858 pub async fn em_with_options(
4859 &self,
4860 params: &DocFormatEmBoundParams,
4861 options: InvokeOptions,
4862 ) -> Result<DocFormatEmResult> {
4863 let params = serde_json::to_value(params)
4864 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4865 let result = self
4866 .invoker
4867 .invoke("doc.format.em", params, options)
4868 .await?;
4869 serde_json::from_value(result).map_err(|decode| {
4870 let mut error = Error::decode(decode);
4871 error.operation_id = Some("doc.format.em".to_owned());
4872 error.outcome_unknown = true;
4873 error
4874 })
4875 }
4876
4877 pub async fn emboss(
4878 &self,
4879 params: &DocFormatEmbossBoundParams,
4880 ) -> Result<DocFormatEmbossResult> {
4881 self.emboss_with_options(params, InvokeOptions::default())
4882 .await
4883 }
4884 pub async fn emboss_with_options(
4885 &self,
4886 params: &DocFormatEmbossBoundParams,
4887 options: InvokeOptions,
4888 ) -> Result<DocFormatEmbossResult> {
4889 let params = serde_json::to_value(params)
4890 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4891 let result = self
4892 .invoker
4893 .invoke("doc.format.emboss", params, options)
4894 .await?;
4895 serde_json::from_value(result).map_err(|decode| {
4896 let mut error = Error::decode(decode);
4897 error.operation_id = Some("doc.format.emboss".to_owned());
4898 error.outcome_unknown = true;
4899 error
4900 })
4901 }
4902
4903 pub async fn fit_text(
4904 &self,
4905 params: &DocFormatFitTextBoundParams,
4906 ) -> Result<DocFormatFitTextResult> {
4907 self.fit_text_with_options(params, InvokeOptions::default())
4908 .await
4909 }
4910 pub async fn fit_text_with_options(
4911 &self,
4912 params: &DocFormatFitTextBoundParams,
4913 options: InvokeOptions,
4914 ) -> Result<DocFormatFitTextResult> {
4915 let params = serde_json::to_value(params)
4916 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4917 let result = self
4918 .invoker
4919 .invoke("doc.format.fitText", params, options)
4920 .await?;
4921 serde_json::from_value(result).map_err(|decode| {
4922 let mut error = Error::decode(decode);
4923 error.operation_id = Some("doc.format.fitText".to_owned());
4924 error.outcome_unknown = true;
4925 error
4926 })
4927 }
4928
4929 pub async fn font_family(
4930 &self,
4931 params: &DocFormatFontFamilyBoundParams,
4932 ) -> Result<DocFormatFontFamilyResult> {
4933 self.font_family_with_options(params, InvokeOptions::default())
4934 .await
4935 }
4936 pub async fn font_family_with_options(
4937 &self,
4938 params: &DocFormatFontFamilyBoundParams,
4939 options: InvokeOptions,
4940 ) -> Result<DocFormatFontFamilyResult> {
4941 let params = serde_json::to_value(params)
4942 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4943 let result = self
4944 .invoker
4945 .invoke("doc.format.fontFamily", params, options)
4946 .await?;
4947 serde_json::from_value(result).map_err(|decode| {
4948 let mut error = Error::decode(decode);
4949 error.operation_id = Some("doc.format.fontFamily".to_owned());
4950 error.outcome_unknown = true;
4951 error
4952 })
4953 }
4954
4955 pub async fn font_size(
4956 &self,
4957 params: &DocFormatFontSizeBoundParams,
4958 ) -> Result<DocFormatFontSizeResult> {
4959 self.font_size_with_options(params, InvokeOptions::default())
4960 .await
4961 }
4962 pub async fn font_size_with_options(
4963 &self,
4964 params: &DocFormatFontSizeBoundParams,
4965 options: InvokeOptions,
4966 ) -> Result<DocFormatFontSizeResult> {
4967 let params = serde_json::to_value(params)
4968 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4969 let result = self
4970 .invoker
4971 .invoke("doc.format.fontSize", params, options)
4972 .await?;
4973 serde_json::from_value(result).map_err(|decode| {
4974 let mut error = Error::decode(decode);
4975 error.operation_id = Some("doc.format.fontSize".to_owned());
4976 error.outcome_unknown = true;
4977 error
4978 })
4979 }
4980
4981 pub async fn font_size_cs(
4982 &self,
4983 params: &DocFormatFontSizeCsBoundParams,
4984 ) -> Result<DocFormatFontSizeCsResult> {
4985 self.font_size_cs_with_options(params, InvokeOptions::default())
4986 .await
4987 }
4988 pub async fn font_size_cs_with_options(
4989 &self,
4990 params: &DocFormatFontSizeCsBoundParams,
4991 options: InvokeOptions,
4992 ) -> Result<DocFormatFontSizeCsResult> {
4993 let params = serde_json::to_value(params)
4994 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
4995 let result = self
4996 .invoker
4997 .invoke("doc.format.fontSizeCs", params, options)
4998 .await?;
4999 serde_json::from_value(result).map_err(|decode| {
5000 let mut error = Error::decode(decode);
5001 error.operation_id = Some("doc.format.fontSizeCs".to_owned());
5002 error.outcome_unknown = true;
5003 error
5004 })
5005 }
5006
5007 pub async fn highlight(
5008 &self,
5009 params: &DocFormatHighlightBoundParams,
5010 ) -> Result<DocFormatHighlightResult> {
5011 self.highlight_with_options(params, InvokeOptions::default())
5012 .await
5013 }
5014 pub async fn highlight_with_options(
5015 &self,
5016 params: &DocFormatHighlightBoundParams,
5017 options: InvokeOptions,
5018 ) -> Result<DocFormatHighlightResult> {
5019 let params = serde_json::to_value(params)
5020 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5021 let result = self
5022 .invoker
5023 .invoke("doc.format.highlight", params, options)
5024 .await?;
5025 serde_json::from_value(result).map_err(|decode| {
5026 let mut error = Error::decode(decode);
5027 error.operation_id = Some("doc.format.highlight".to_owned());
5028 error.outcome_unknown = true;
5029 error
5030 })
5031 }
5032
5033 pub async fn i_cs(&self, params: &DocFormatICsBoundParams) -> Result<DocFormatICsResult> {
5034 self.i_cs_with_options(params, InvokeOptions::default())
5035 .await
5036 }
5037 pub async fn i_cs_with_options(
5038 &self,
5039 params: &DocFormatICsBoundParams,
5040 options: InvokeOptions,
5041 ) -> Result<DocFormatICsResult> {
5042 let params = serde_json::to_value(params)
5043 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5044 let result = self
5045 .invoker
5046 .invoke("doc.format.iCs", params, options)
5047 .await?;
5048 serde_json::from_value(result).map_err(|decode| {
5049 let mut error = Error::decode(decode);
5050 error.operation_id = Some("doc.format.iCs".to_owned());
5051 error.outcome_unknown = true;
5052 error
5053 })
5054 }
5055
5056 pub async fn imprint(
5057 &self,
5058 params: &DocFormatImprintBoundParams,
5059 ) -> Result<DocFormatImprintResult> {
5060 self.imprint_with_options(params, InvokeOptions::default())
5061 .await
5062 }
5063 pub async fn imprint_with_options(
5064 &self,
5065 params: &DocFormatImprintBoundParams,
5066 options: InvokeOptions,
5067 ) -> Result<DocFormatImprintResult> {
5068 let params = serde_json::to_value(params)
5069 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5070 let result = self
5071 .invoker
5072 .invoke("doc.format.imprint", params, options)
5073 .await?;
5074 serde_json::from_value(result).map_err(|decode| {
5075 let mut error = Error::decode(decode);
5076 error.operation_id = Some("doc.format.imprint".to_owned());
5077 error.outcome_unknown = true;
5078 error
5079 })
5080 }
5081
5082 pub async fn italic(
5083 &self,
5084 params: &DocFormatItalicBoundParams,
5085 ) -> Result<DocFormatItalicResult> {
5086 self.italic_with_options(params, InvokeOptions::default())
5087 .await
5088 }
5089 pub async fn italic_with_options(
5090 &self,
5091 params: &DocFormatItalicBoundParams,
5092 options: InvokeOptions,
5093 ) -> Result<DocFormatItalicResult> {
5094 let params = serde_json::to_value(params)
5095 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5096 let result = self
5097 .invoker
5098 .invoke("doc.format.italic", params, options)
5099 .await?;
5100 serde_json::from_value(result).map_err(|decode| {
5101 let mut error = Error::decode(decode);
5102 error.operation_id = Some("doc.format.italic".to_owned());
5103 error.outcome_unknown = true;
5104 error
5105 })
5106 }
5107
5108 pub async fn kerning(
5109 &self,
5110 params: &DocFormatKerningBoundParams,
5111 ) -> Result<DocFormatKerningResult> {
5112 self.kerning_with_options(params, InvokeOptions::default())
5113 .await
5114 }
5115 pub async fn kerning_with_options(
5116 &self,
5117 params: &DocFormatKerningBoundParams,
5118 options: InvokeOptions,
5119 ) -> Result<DocFormatKerningResult> {
5120 let params = serde_json::to_value(params)
5121 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5122 let result = self
5123 .invoker
5124 .invoke("doc.format.kerning", params, options)
5125 .await?;
5126 serde_json::from_value(result).map_err(|decode| {
5127 let mut error = Error::decode(decode);
5128 error.operation_id = Some("doc.format.kerning".to_owned());
5129 error.outcome_unknown = true;
5130 error
5131 })
5132 }
5133
5134 pub async fn lang(&self, params: &DocFormatLangBoundParams) -> Result<DocFormatLangResult> {
5135 self.lang_with_options(params, InvokeOptions::default())
5136 .await
5137 }
5138 pub async fn lang_with_options(
5139 &self,
5140 params: &DocFormatLangBoundParams,
5141 options: InvokeOptions,
5142 ) -> Result<DocFormatLangResult> {
5143 let params = serde_json::to_value(params)
5144 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5145 let result = self
5146 .invoker
5147 .invoke("doc.format.lang", params, options)
5148 .await?;
5149 serde_json::from_value(result).map_err(|decode| {
5150 let mut error = Error::decode(decode);
5151 error.operation_id = Some("doc.format.lang".to_owned());
5152 error.outcome_unknown = true;
5153 error
5154 })
5155 }
5156
5157 pub async fn letter_spacing(
5158 &self,
5159 params: &DocFormatLetterSpacingBoundParams,
5160 ) -> Result<DocFormatLetterSpacingResult> {
5161 self.letter_spacing_with_options(params, InvokeOptions::default())
5162 .await
5163 }
5164 pub async fn letter_spacing_with_options(
5165 &self,
5166 params: &DocFormatLetterSpacingBoundParams,
5167 options: InvokeOptions,
5168 ) -> Result<DocFormatLetterSpacingResult> {
5169 let params = serde_json::to_value(params)
5170 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5171 let result = self
5172 .invoker
5173 .invoke("doc.format.letterSpacing", params, options)
5174 .await?;
5175 serde_json::from_value(result).map_err(|decode| {
5176 let mut error = Error::decode(decode);
5177 error.operation_id = Some("doc.format.letterSpacing".to_owned());
5178 error.outcome_unknown = true;
5179 error
5180 })
5181 }
5182
5183 pub async fn ligatures(
5184 &self,
5185 params: &DocFormatLigaturesBoundParams,
5186 ) -> Result<DocFormatLigaturesResult> {
5187 self.ligatures_with_options(params, InvokeOptions::default())
5188 .await
5189 }
5190 pub async fn ligatures_with_options(
5191 &self,
5192 params: &DocFormatLigaturesBoundParams,
5193 options: InvokeOptions,
5194 ) -> Result<DocFormatLigaturesResult> {
5195 let params = serde_json::to_value(params)
5196 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5197 let result = self
5198 .invoker
5199 .invoke("doc.format.ligatures", params, options)
5200 .await?;
5201 serde_json::from_value(result).map_err(|decode| {
5202 let mut error = Error::decode(decode);
5203 error.operation_id = Some("doc.format.ligatures".to_owned());
5204 error.outcome_unknown = true;
5205 error
5206 })
5207 }
5208
5209 pub async fn num_form(
5210 &self,
5211 params: &DocFormatNumFormBoundParams,
5212 ) -> Result<DocFormatNumFormResult> {
5213 self.num_form_with_options(params, InvokeOptions::default())
5214 .await
5215 }
5216 pub async fn num_form_with_options(
5217 &self,
5218 params: &DocFormatNumFormBoundParams,
5219 options: InvokeOptions,
5220 ) -> Result<DocFormatNumFormResult> {
5221 let params = serde_json::to_value(params)
5222 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5223 let result = self
5224 .invoker
5225 .invoke("doc.format.numForm", params, options)
5226 .await?;
5227 serde_json::from_value(result).map_err(|decode| {
5228 let mut error = Error::decode(decode);
5229 error.operation_id = Some("doc.format.numForm".to_owned());
5230 error.outcome_unknown = true;
5231 error
5232 })
5233 }
5234
5235 pub async fn num_spacing(
5236 &self,
5237 params: &DocFormatNumSpacingBoundParams,
5238 ) -> Result<DocFormatNumSpacingResult> {
5239 self.num_spacing_with_options(params, InvokeOptions::default())
5240 .await
5241 }
5242 pub async fn num_spacing_with_options(
5243 &self,
5244 params: &DocFormatNumSpacingBoundParams,
5245 options: InvokeOptions,
5246 ) -> Result<DocFormatNumSpacingResult> {
5247 let params = serde_json::to_value(params)
5248 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5249 let result = self
5250 .invoker
5251 .invoke("doc.format.numSpacing", params, options)
5252 .await?;
5253 serde_json::from_value(result).map_err(|decode| {
5254 let mut error = Error::decode(decode);
5255 error.operation_id = Some("doc.format.numSpacing".to_owned());
5256 error.outcome_unknown = true;
5257 error
5258 })
5259 }
5260
5261 pub async fn o_math(&self, params: &DocFormatOMathBoundParams) -> Result<DocFormatOMathResult> {
5262 self.o_math_with_options(params, InvokeOptions::default())
5263 .await
5264 }
5265 pub async fn o_math_with_options(
5266 &self,
5267 params: &DocFormatOMathBoundParams,
5268 options: InvokeOptions,
5269 ) -> Result<DocFormatOMathResult> {
5270 let params = serde_json::to_value(params)
5271 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5272 let result = self
5273 .invoker
5274 .invoke("doc.format.oMath", params, options)
5275 .await?;
5276 serde_json::from_value(result).map_err(|decode| {
5277 let mut error = Error::decode(decode);
5278 error.operation_id = Some("doc.format.oMath".to_owned());
5279 error.outcome_unknown = true;
5280 error
5281 })
5282 }
5283
5284 pub async fn outline(
5285 &self,
5286 params: &DocFormatOutlineBoundParams,
5287 ) -> Result<DocFormatOutlineResult> {
5288 self.outline_with_options(params, InvokeOptions::default())
5289 .await
5290 }
5291 pub async fn outline_with_options(
5292 &self,
5293 params: &DocFormatOutlineBoundParams,
5294 options: InvokeOptions,
5295 ) -> Result<DocFormatOutlineResult> {
5296 let params = serde_json::to_value(params)
5297 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5298 let result = self
5299 .invoker
5300 .invoke("doc.format.outline", params, options)
5301 .await?;
5302 serde_json::from_value(result).map_err(|decode| {
5303 let mut error = Error::decode(decode);
5304 error.operation_id = Some("doc.format.outline".to_owned());
5305 error.outcome_unknown = true;
5306 error
5307 })
5308 }
5309
5310 pub async fn position(
5311 &self,
5312 params: &DocFormatPositionBoundParams,
5313 ) -> Result<DocFormatPositionResult> {
5314 self.position_with_options(params, InvokeOptions::default())
5315 .await
5316 }
5317 pub async fn position_with_options(
5318 &self,
5319 params: &DocFormatPositionBoundParams,
5320 options: InvokeOptions,
5321 ) -> Result<DocFormatPositionResult> {
5322 let params = serde_json::to_value(params)
5323 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5324 let result = self
5325 .invoker
5326 .invoke("doc.format.position", params, options)
5327 .await?;
5328 serde_json::from_value(result).map_err(|decode| {
5329 let mut error = Error::decode(decode);
5330 error.operation_id = Some("doc.format.position".to_owned());
5331 error.outcome_unknown = true;
5332 error
5333 })
5334 }
5335
5336 pub async fn read_selection(
5337 &self,
5338 params: &DocFormatReadSelectionBoundParams,
5339 ) -> Result<DocFormatReadSelectionResult> {
5340 self.read_selection_with_options(params, InvokeOptions::default())
5341 .await
5342 }
5343 pub async fn read_selection_with_options(
5344 &self,
5345 params: &DocFormatReadSelectionBoundParams,
5346 options: InvokeOptions,
5347 ) -> Result<DocFormatReadSelectionResult> {
5348 let params = serde_json::to_value(params)
5349 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5350 let result = self
5351 .invoker
5352 .invoke("doc.format.readSelection", params, options)
5353 .await?;
5354 serde_json::from_value(result).map_err(|decode| {
5355 let mut error = Error::decode(decode);
5356 error.operation_id = Some("doc.format.readSelection".to_owned());
5357 error.outcome_unknown = false;
5358 error
5359 })
5360 }
5361
5362 pub async fn r_fonts(
5363 &self,
5364 params: &DocFormatRFontsBoundParams,
5365 ) -> Result<DocFormatRFontsResult> {
5366 self.r_fonts_with_options(params, InvokeOptions::default())
5367 .await
5368 }
5369 pub async fn r_fonts_with_options(
5370 &self,
5371 params: &DocFormatRFontsBoundParams,
5372 options: InvokeOptions,
5373 ) -> Result<DocFormatRFontsResult> {
5374 let params = serde_json::to_value(params)
5375 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5376 let result = self
5377 .invoker
5378 .invoke("doc.format.rFonts", params, options)
5379 .await?;
5380 serde_json::from_value(result).map_err(|decode| {
5381 let mut error = Error::decode(decode);
5382 error.operation_id = Some("doc.format.rFonts".to_owned());
5383 error.outcome_unknown = true;
5384 error
5385 })
5386 }
5387
5388 pub async fn r_style(
5389 &self,
5390 params: &DocFormatRStyleBoundParams,
5391 ) -> Result<DocFormatRStyleResult> {
5392 self.r_style_with_options(params, InvokeOptions::default())
5393 .await
5394 }
5395 pub async fn r_style_with_options(
5396 &self,
5397 params: &DocFormatRStyleBoundParams,
5398 options: InvokeOptions,
5399 ) -> Result<DocFormatRStyleResult> {
5400 let params = serde_json::to_value(params)
5401 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5402 let result = self
5403 .invoker
5404 .invoke("doc.format.rStyle", params, options)
5405 .await?;
5406 serde_json::from_value(result).map_err(|decode| {
5407 let mut error = Error::decode(decode);
5408 error.operation_id = Some("doc.format.rStyle".to_owned());
5409 error.outcome_unknown = true;
5410 error
5411 })
5412 }
5413
5414 pub async fn rtl(&self, params: &DocFormatRtlBoundParams) -> Result<DocFormatRtlResult> {
5415 self.rtl_with_options(params, InvokeOptions::default())
5416 .await
5417 }
5418 pub async fn rtl_with_options(
5419 &self,
5420 params: &DocFormatRtlBoundParams,
5421 options: InvokeOptions,
5422 ) -> Result<DocFormatRtlResult> {
5423 let params = serde_json::to_value(params)
5424 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5425 let result = self
5426 .invoker
5427 .invoke("doc.format.rtl", params, options)
5428 .await?;
5429 serde_json::from_value(result).map_err(|decode| {
5430 let mut error = Error::decode(decode);
5431 error.operation_id = Some("doc.format.rtl".to_owned());
5432 error.outcome_unknown = true;
5433 error
5434 })
5435 }
5436
5437 pub async fn shading(
5438 &self,
5439 params: &DocFormatShadingBoundParams,
5440 ) -> Result<DocFormatShadingResult> {
5441 self.shading_with_options(params, InvokeOptions::default())
5442 .await
5443 }
5444 pub async fn shading_with_options(
5445 &self,
5446 params: &DocFormatShadingBoundParams,
5447 options: InvokeOptions,
5448 ) -> Result<DocFormatShadingResult> {
5449 let params = serde_json::to_value(params)
5450 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5451 let result = self
5452 .invoker
5453 .invoke("doc.format.shading", params, options)
5454 .await?;
5455 serde_json::from_value(result).map_err(|decode| {
5456 let mut error = Error::decode(decode);
5457 error.operation_id = Some("doc.format.shading".to_owned());
5458 error.outcome_unknown = true;
5459 error
5460 })
5461 }
5462
5463 pub async fn shadow(
5464 &self,
5465 params: &DocFormatShadowBoundParams,
5466 ) -> Result<DocFormatShadowResult> {
5467 self.shadow_with_options(params, InvokeOptions::default())
5468 .await
5469 }
5470 pub async fn shadow_with_options(
5471 &self,
5472 params: &DocFormatShadowBoundParams,
5473 options: InvokeOptions,
5474 ) -> Result<DocFormatShadowResult> {
5475 let params = serde_json::to_value(params)
5476 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5477 let result = self
5478 .invoker
5479 .invoke("doc.format.shadow", params, options)
5480 .await?;
5481 serde_json::from_value(result).map_err(|decode| {
5482 let mut error = Error::decode(decode);
5483 error.operation_id = Some("doc.format.shadow".to_owned());
5484 error.outcome_unknown = true;
5485 error
5486 })
5487 }
5488
5489 pub async fn small_caps(
5490 &self,
5491 params: &DocFormatSmallCapsBoundParams,
5492 ) -> Result<DocFormatSmallCapsResult> {
5493 self.small_caps_with_options(params, InvokeOptions::default())
5494 .await
5495 }
5496 pub async fn small_caps_with_options(
5497 &self,
5498 params: &DocFormatSmallCapsBoundParams,
5499 options: InvokeOptions,
5500 ) -> Result<DocFormatSmallCapsResult> {
5501 let params = serde_json::to_value(params)
5502 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5503 let result = self
5504 .invoker
5505 .invoke("doc.format.smallCaps", params, options)
5506 .await?;
5507 serde_json::from_value(result).map_err(|decode| {
5508 let mut error = Error::decode(decode);
5509 error.operation_id = Some("doc.format.smallCaps".to_owned());
5510 error.outcome_unknown = true;
5511 error
5512 })
5513 }
5514
5515 pub async fn snap_to_grid(
5516 &self,
5517 params: &DocFormatSnapToGridBoundParams,
5518 ) -> Result<DocFormatSnapToGridResult> {
5519 self.snap_to_grid_with_options(params, InvokeOptions::default())
5520 .await
5521 }
5522 pub async fn snap_to_grid_with_options(
5523 &self,
5524 params: &DocFormatSnapToGridBoundParams,
5525 options: InvokeOptions,
5526 ) -> Result<DocFormatSnapToGridResult> {
5527 let params = serde_json::to_value(params)
5528 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5529 let result = self
5530 .invoker
5531 .invoke("doc.format.snapToGrid", params, options)
5532 .await?;
5533 serde_json::from_value(result).map_err(|decode| {
5534 let mut error = Error::decode(decode);
5535 error.operation_id = Some("doc.format.snapToGrid".to_owned());
5536 error.outcome_unknown = true;
5537 error
5538 })
5539 }
5540
5541 pub async fn spec_vanish(
5542 &self,
5543 params: &DocFormatSpecVanishBoundParams,
5544 ) -> Result<DocFormatSpecVanishResult> {
5545 self.spec_vanish_with_options(params, InvokeOptions::default())
5546 .await
5547 }
5548 pub async fn spec_vanish_with_options(
5549 &self,
5550 params: &DocFormatSpecVanishBoundParams,
5551 options: InvokeOptions,
5552 ) -> Result<DocFormatSpecVanishResult> {
5553 let params = serde_json::to_value(params)
5554 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5555 let result = self
5556 .invoker
5557 .invoke("doc.format.specVanish", params, options)
5558 .await?;
5559 serde_json::from_value(result).map_err(|decode| {
5560 let mut error = Error::decode(decode);
5561 error.operation_id = Some("doc.format.specVanish".to_owned());
5562 error.outcome_unknown = true;
5563 error
5564 })
5565 }
5566
5567 pub async fn strike(
5568 &self,
5569 params: &DocFormatStrikeBoundParams,
5570 ) -> Result<DocFormatStrikeResult> {
5571 self.strike_with_options(params, InvokeOptions::default())
5572 .await
5573 }
5574 pub async fn strike_with_options(
5575 &self,
5576 params: &DocFormatStrikeBoundParams,
5577 options: InvokeOptions,
5578 ) -> Result<DocFormatStrikeResult> {
5579 let params = serde_json::to_value(params)
5580 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5581 let result = self
5582 .invoker
5583 .invoke("doc.format.strike", params, options)
5584 .await?;
5585 serde_json::from_value(result).map_err(|decode| {
5586 let mut error = Error::decode(decode);
5587 error.operation_id = Some("doc.format.strike".to_owned());
5588 error.outcome_unknown = true;
5589 error
5590 })
5591 }
5592
5593 pub async fn stylistic_sets(
5594 &self,
5595 params: &DocFormatStylisticSetsBoundParams,
5596 ) -> Result<DocFormatStylisticSetsResult> {
5597 self.stylistic_sets_with_options(params, InvokeOptions::default())
5598 .await
5599 }
5600 pub async fn stylistic_sets_with_options(
5601 &self,
5602 params: &DocFormatStylisticSetsBoundParams,
5603 options: InvokeOptions,
5604 ) -> Result<DocFormatStylisticSetsResult> {
5605 let params = serde_json::to_value(params)
5606 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5607 let result = self
5608 .invoker
5609 .invoke("doc.format.stylisticSets", params, options)
5610 .await?;
5611 serde_json::from_value(result).map_err(|decode| {
5612 let mut error = Error::decode(decode);
5613 error.operation_id = Some("doc.format.stylisticSets".to_owned());
5614 error.outcome_unknown = true;
5615 error
5616 })
5617 }
5618
5619 pub async fn underline(
5620 &self,
5621 params: &DocFormatUnderlineBoundParams,
5622 ) -> Result<DocFormatUnderlineResult> {
5623 self.underline_with_options(params, InvokeOptions::default())
5624 .await
5625 }
5626 pub async fn underline_with_options(
5627 &self,
5628 params: &DocFormatUnderlineBoundParams,
5629 options: InvokeOptions,
5630 ) -> Result<DocFormatUnderlineResult> {
5631 let params = serde_json::to_value(params)
5632 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5633 let result = self
5634 .invoker
5635 .invoke("doc.format.underline", params, options)
5636 .await?;
5637 serde_json::from_value(result).map_err(|decode| {
5638 let mut error = Error::decode(decode);
5639 error.operation_id = Some("doc.format.underline".to_owned());
5640 error.outcome_unknown = true;
5641 error
5642 })
5643 }
5644
5645 pub async fn vanish(
5646 &self,
5647 params: &DocFormatVanishBoundParams,
5648 ) -> Result<DocFormatVanishResult> {
5649 self.vanish_with_options(params, InvokeOptions::default())
5650 .await
5651 }
5652 pub async fn vanish_with_options(
5653 &self,
5654 params: &DocFormatVanishBoundParams,
5655 options: InvokeOptions,
5656 ) -> Result<DocFormatVanishResult> {
5657 let params = serde_json::to_value(params)
5658 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5659 let result = self
5660 .invoker
5661 .invoke("doc.format.vanish", params, options)
5662 .await?;
5663 serde_json::from_value(result).map_err(|decode| {
5664 let mut error = Error::decode(decode);
5665 error.operation_id = Some("doc.format.vanish".to_owned());
5666 error.outcome_unknown = true;
5667 error
5668 })
5669 }
5670
5671 pub async fn vert_align(
5672 &self,
5673 params: &DocFormatVertAlignBoundParams,
5674 ) -> Result<DocFormatVertAlignResult> {
5675 self.vert_align_with_options(params, InvokeOptions::default())
5676 .await
5677 }
5678 pub async fn vert_align_with_options(
5679 &self,
5680 params: &DocFormatVertAlignBoundParams,
5681 options: InvokeOptions,
5682 ) -> Result<DocFormatVertAlignResult> {
5683 let params = serde_json::to_value(params)
5684 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5685 let result = self
5686 .invoker
5687 .invoke("doc.format.vertAlign", params, options)
5688 .await?;
5689 serde_json::from_value(result).map_err(|decode| {
5690 let mut error = Error::decode(decode);
5691 error.operation_id = Some("doc.format.vertAlign".to_owned());
5692 error.outcome_unknown = true;
5693 error
5694 })
5695 }
5696
5697 pub async fn web_hidden(
5698 &self,
5699 params: &DocFormatWebHiddenBoundParams,
5700 ) -> Result<DocFormatWebHiddenResult> {
5701 self.web_hidden_with_options(params, InvokeOptions::default())
5702 .await
5703 }
5704 pub async fn web_hidden_with_options(
5705 &self,
5706 params: &DocFormatWebHiddenBoundParams,
5707 options: InvokeOptions,
5708 ) -> Result<DocFormatWebHiddenResult> {
5709 let params = serde_json::to_value(params)
5710 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5711 let result = self
5712 .invoker
5713 .invoke("doc.format.webHidden", params, options)
5714 .await?;
5715 serde_json::from_value(result).map_err(|decode| {
5716 let mut error = Error::decode(decode);
5717 error.operation_id = Some("doc.format.webHidden".to_owned());
5718 error.outcome_unknown = true;
5719 error
5720 })
5721 }
5722}
5723
5724pub struct DocApiFormatParagraph<'a, I: Invoker> {
5725 invoker: &'a I,
5726}
5727impl<'a, I: Invoker> DocApiFormatParagraph<'a, I> {
5728 pub fn new(invoker: &'a I) -> Self {
5729 Self { invoker }
5730 }
5731
5732 pub async fn clear_alignment(
5733 &self,
5734 params: &DocFormatParagraphClearAlignmentBoundParams,
5735 ) -> Result<DocFormatParagraphClearAlignmentResult> {
5736 self.clear_alignment_with_options(params, InvokeOptions::default())
5737 .await
5738 }
5739 pub async fn clear_alignment_with_options(
5740 &self,
5741 params: &DocFormatParagraphClearAlignmentBoundParams,
5742 options: InvokeOptions,
5743 ) -> Result<DocFormatParagraphClearAlignmentResult> {
5744 let params = serde_json::to_value(params)
5745 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5746 let result = self
5747 .invoker
5748 .invoke("doc.format.paragraph.clearAlignment", params, options)
5749 .await?;
5750 serde_json::from_value(result).map_err(|decode| {
5751 let mut error = Error::decode(decode);
5752 error.operation_id = Some("doc.format.paragraph.clearAlignment".to_owned());
5753 error.outcome_unknown = true;
5754 error
5755 })
5756 }
5757
5758 pub async fn clear_all_tab_stops(
5759 &self,
5760 params: &DocFormatParagraphClearAllTabStopsBoundParams,
5761 ) -> Result<DocFormatParagraphClearAllTabStopsResult> {
5762 self.clear_all_tab_stops_with_options(params, InvokeOptions::default())
5763 .await
5764 }
5765 pub async fn clear_all_tab_stops_with_options(
5766 &self,
5767 params: &DocFormatParagraphClearAllTabStopsBoundParams,
5768 options: InvokeOptions,
5769 ) -> Result<DocFormatParagraphClearAllTabStopsResult> {
5770 let params = serde_json::to_value(params)
5771 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5772 let result = self
5773 .invoker
5774 .invoke("doc.format.paragraph.clearAllTabStops", params, options)
5775 .await?;
5776 serde_json::from_value(result).map_err(|decode| {
5777 let mut error = Error::decode(decode);
5778 error.operation_id = Some("doc.format.paragraph.clearAllTabStops".to_owned());
5779 error.outcome_unknown = true;
5780 error
5781 })
5782 }
5783
5784 pub async fn clear_border(
5785 &self,
5786 params: &DocFormatParagraphClearBorderBoundParams,
5787 ) -> Result<DocFormatParagraphClearBorderResult> {
5788 self.clear_border_with_options(params, InvokeOptions::default())
5789 .await
5790 }
5791 pub async fn clear_border_with_options(
5792 &self,
5793 params: &DocFormatParagraphClearBorderBoundParams,
5794 options: InvokeOptions,
5795 ) -> Result<DocFormatParagraphClearBorderResult> {
5796 let params = serde_json::to_value(params)
5797 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5798 let result = self
5799 .invoker
5800 .invoke("doc.format.paragraph.clearBorder", params, options)
5801 .await?;
5802 serde_json::from_value(result).map_err(|decode| {
5803 let mut error = Error::decode(decode);
5804 error.operation_id = Some("doc.format.paragraph.clearBorder".to_owned());
5805 error.outcome_unknown = true;
5806 error
5807 })
5808 }
5809
5810 pub async fn clear_direction(
5811 &self,
5812 params: &DocFormatParagraphClearDirectionBoundParams,
5813 ) -> Result<DocFormatParagraphClearDirectionResult> {
5814 self.clear_direction_with_options(params, InvokeOptions::default())
5815 .await
5816 }
5817 pub async fn clear_direction_with_options(
5818 &self,
5819 params: &DocFormatParagraphClearDirectionBoundParams,
5820 options: InvokeOptions,
5821 ) -> Result<DocFormatParagraphClearDirectionResult> {
5822 let params = serde_json::to_value(params)
5823 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5824 let result = self
5825 .invoker
5826 .invoke("doc.format.paragraph.clearDirection", params, options)
5827 .await?;
5828 serde_json::from_value(result).map_err(|decode| {
5829 let mut error = Error::decode(decode);
5830 error.operation_id = Some("doc.format.paragraph.clearDirection".to_owned());
5831 error.outcome_unknown = true;
5832 error
5833 })
5834 }
5835
5836 pub async fn clear_indentation(
5837 &self,
5838 params: &DocFormatParagraphClearIndentationBoundParams,
5839 ) -> Result<DocFormatParagraphClearIndentationResult> {
5840 self.clear_indentation_with_options(params, InvokeOptions::default())
5841 .await
5842 }
5843 pub async fn clear_indentation_with_options(
5844 &self,
5845 params: &DocFormatParagraphClearIndentationBoundParams,
5846 options: InvokeOptions,
5847 ) -> Result<DocFormatParagraphClearIndentationResult> {
5848 let params = serde_json::to_value(params)
5849 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5850 let result = self
5851 .invoker
5852 .invoke("doc.format.paragraph.clearIndentation", params, options)
5853 .await?;
5854 serde_json::from_value(result).map_err(|decode| {
5855 let mut error = Error::decode(decode);
5856 error.operation_id = Some("doc.format.paragraph.clearIndentation".to_owned());
5857 error.outcome_unknown = true;
5858 error
5859 })
5860 }
5861
5862 pub async fn clear_shading(
5863 &self,
5864 params: &DocFormatParagraphClearShadingBoundParams,
5865 ) -> Result<DocFormatParagraphClearShadingResult> {
5866 self.clear_shading_with_options(params, InvokeOptions::default())
5867 .await
5868 }
5869 pub async fn clear_shading_with_options(
5870 &self,
5871 params: &DocFormatParagraphClearShadingBoundParams,
5872 options: InvokeOptions,
5873 ) -> Result<DocFormatParagraphClearShadingResult> {
5874 let params = serde_json::to_value(params)
5875 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5876 let result = self
5877 .invoker
5878 .invoke("doc.format.paragraph.clearShading", params, options)
5879 .await?;
5880 serde_json::from_value(result).map_err(|decode| {
5881 let mut error = Error::decode(decode);
5882 error.operation_id = Some("doc.format.paragraph.clearShading".to_owned());
5883 error.outcome_unknown = true;
5884 error
5885 })
5886 }
5887
5888 pub async fn clear_spacing(
5889 &self,
5890 params: &DocFormatParagraphClearSpacingBoundParams,
5891 ) -> Result<DocFormatParagraphClearSpacingResult> {
5892 self.clear_spacing_with_options(params, InvokeOptions::default())
5893 .await
5894 }
5895 pub async fn clear_spacing_with_options(
5896 &self,
5897 params: &DocFormatParagraphClearSpacingBoundParams,
5898 options: InvokeOptions,
5899 ) -> Result<DocFormatParagraphClearSpacingResult> {
5900 let params = serde_json::to_value(params)
5901 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5902 let result = self
5903 .invoker
5904 .invoke("doc.format.paragraph.clearSpacing", params, options)
5905 .await?;
5906 serde_json::from_value(result).map_err(|decode| {
5907 let mut error = Error::decode(decode);
5908 error.operation_id = Some("doc.format.paragraph.clearSpacing".to_owned());
5909 error.outcome_unknown = true;
5910 error
5911 })
5912 }
5913
5914 pub async fn clear_tab_stop(
5915 &self,
5916 params: &DocFormatParagraphClearTabStopBoundParams,
5917 ) -> Result<DocFormatParagraphClearTabStopResult> {
5918 self.clear_tab_stop_with_options(params, InvokeOptions::default())
5919 .await
5920 }
5921 pub async fn clear_tab_stop_with_options(
5922 &self,
5923 params: &DocFormatParagraphClearTabStopBoundParams,
5924 options: InvokeOptions,
5925 ) -> Result<DocFormatParagraphClearTabStopResult> {
5926 let params = serde_json::to_value(params)
5927 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5928 let result = self
5929 .invoker
5930 .invoke("doc.format.paragraph.clearTabStop", params, options)
5931 .await?;
5932 serde_json::from_value(result).map_err(|decode| {
5933 let mut error = Error::decode(decode);
5934 error.operation_id = Some("doc.format.paragraph.clearTabStop".to_owned());
5935 error.outcome_unknown = true;
5936 error
5937 })
5938 }
5939
5940 pub async fn reset_direct_formatting(
5941 &self,
5942 params: &DocFormatParagraphResetDirectFormattingBoundParams,
5943 ) -> Result<DocFormatParagraphResetDirectFormattingResult> {
5944 self.reset_direct_formatting_with_options(params, InvokeOptions::default())
5945 .await
5946 }
5947 pub async fn reset_direct_formatting_with_options(
5948 &self,
5949 params: &DocFormatParagraphResetDirectFormattingBoundParams,
5950 options: InvokeOptions,
5951 ) -> Result<DocFormatParagraphResetDirectFormattingResult> {
5952 let params = serde_json::to_value(params)
5953 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5954 let result = self
5955 .invoker
5956 .invoke(
5957 "doc.format.paragraph.resetDirectFormatting",
5958 params,
5959 options,
5960 )
5961 .await?;
5962 serde_json::from_value(result).map_err(|decode| {
5963 let mut error = Error::decode(decode);
5964 error.operation_id = Some("doc.format.paragraph.resetDirectFormatting".to_owned());
5965 error.outcome_unknown = true;
5966 error
5967 })
5968 }
5969
5970 pub async fn set_alignment(
5971 &self,
5972 params: &DocFormatParagraphSetAlignmentBoundParams,
5973 ) -> Result<DocFormatParagraphSetAlignmentResult> {
5974 self.set_alignment_with_options(params, InvokeOptions::default())
5975 .await
5976 }
5977 pub async fn set_alignment_with_options(
5978 &self,
5979 params: &DocFormatParagraphSetAlignmentBoundParams,
5980 options: InvokeOptions,
5981 ) -> Result<DocFormatParagraphSetAlignmentResult> {
5982 let params = serde_json::to_value(params)
5983 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
5984 let result = self
5985 .invoker
5986 .invoke("doc.format.paragraph.setAlignment", params, options)
5987 .await?;
5988 serde_json::from_value(result).map_err(|decode| {
5989 let mut error = Error::decode(decode);
5990 error.operation_id = Some("doc.format.paragraph.setAlignment".to_owned());
5991 error.outcome_unknown = true;
5992 error
5993 })
5994 }
5995
5996 pub async fn set_border(
5997 &self,
5998 params: &DocFormatParagraphSetBorderBoundParams,
5999 ) -> Result<DocFormatParagraphSetBorderResult> {
6000 self.set_border_with_options(params, InvokeOptions::default())
6001 .await
6002 }
6003 pub async fn set_border_with_options(
6004 &self,
6005 params: &DocFormatParagraphSetBorderBoundParams,
6006 options: InvokeOptions,
6007 ) -> Result<DocFormatParagraphSetBorderResult> {
6008 let params = serde_json::to_value(params)
6009 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6010 let result = self
6011 .invoker
6012 .invoke("doc.format.paragraph.setBorder", params, options)
6013 .await?;
6014 serde_json::from_value(result).map_err(|decode| {
6015 let mut error = Error::decode(decode);
6016 error.operation_id = Some("doc.format.paragraph.setBorder".to_owned());
6017 error.outcome_unknown = true;
6018 error
6019 })
6020 }
6021
6022 pub async fn set_direction(
6023 &self,
6024 params: &DocFormatParagraphSetDirectionBoundParams,
6025 ) -> Result<DocFormatParagraphSetDirectionResult> {
6026 self.set_direction_with_options(params, InvokeOptions::default())
6027 .await
6028 }
6029 pub async fn set_direction_with_options(
6030 &self,
6031 params: &DocFormatParagraphSetDirectionBoundParams,
6032 options: InvokeOptions,
6033 ) -> Result<DocFormatParagraphSetDirectionResult> {
6034 let params = serde_json::to_value(params)
6035 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6036 let result = self
6037 .invoker
6038 .invoke("doc.format.paragraph.setDirection", params, options)
6039 .await?;
6040 serde_json::from_value(result).map_err(|decode| {
6041 let mut error = Error::decode(decode);
6042 error.operation_id = Some("doc.format.paragraph.setDirection".to_owned());
6043 error.outcome_unknown = true;
6044 error
6045 })
6046 }
6047
6048 pub async fn set_flow_options(
6049 &self,
6050 params: &DocFormatParagraphSetFlowOptionsBoundParams,
6051 ) -> Result<DocFormatParagraphSetFlowOptionsResult> {
6052 self.set_flow_options_with_options(params, InvokeOptions::default())
6053 .await
6054 }
6055 pub async fn set_flow_options_with_options(
6056 &self,
6057 params: &DocFormatParagraphSetFlowOptionsBoundParams,
6058 options: InvokeOptions,
6059 ) -> Result<DocFormatParagraphSetFlowOptionsResult> {
6060 let params = serde_json::to_value(params)
6061 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6062 let result = self
6063 .invoker
6064 .invoke("doc.format.paragraph.setFlowOptions", params, options)
6065 .await?;
6066 serde_json::from_value(result).map_err(|decode| {
6067 let mut error = Error::decode(decode);
6068 error.operation_id = Some("doc.format.paragraph.setFlowOptions".to_owned());
6069 error.outcome_unknown = true;
6070 error
6071 })
6072 }
6073
6074 pub async fn set_indentation(
6075 &self,
6076 params: &DocFormatParagraphSetIndentationBoundParams,
6077 ) -> Result<DocFormatParagraphSetIndentationResult> {
6078 self.set_indentation_with_options(params, InvokeOptions::default())
6079 .await
6080 }
6081 pub async fn set_indentation_with_options(
6082 &self,
6083 params: &DocFormatParagraphSetIndentationBoundParams,
6084 options: InvokeOptions,
6085 ) -> Result<DocFormatParagraphSetIndentationResult> {
6086 let params = serde_json::to_value(params)
6087 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6088 let result = self
6089 .invoker
6090 .invoke("doc.format.paragraph.setIndentation", params, options)
6091 .await?;
6092 serde_json::from_value(result).map_err(|decode| {
6093 let mut error = Error::decode(decode);
6094 error.operation_id = Some("doc.format.paragraph.setIndentation".to_owned());
6095 error.outcome_unknown = true;
6096 error
6097 })
6098 }
6099
6100 pub async fn set_keep_options(
6101 &self,
6102 params: &DocFormatParagraphSetKeepOptionsBoundParams,
6103 ) -> Result<DocFormatParagraphSetKeepOptionsResult> {
6104 self.set_keep_options_with_options(params, InvokeOptions::default())
6105 .await
6106 }
6107 pub async fn set_keep_options_with_options(
6108 &self,
6109 params: &DocFormatParagraphSetKeepOptionsBoundParams,
6110 options: InvokeOptions,
6111 ) -> Result<DocFormatParagraphSetKeepOptionsResult> {
6112 let params = serde_json::to_value(params)
6113 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6114 let result = self
6115 .invoker
6116 .invoke("doc.format.paragraph.setKeepOptions", params, options)
6117 .await?;
6118 serde_json::from_value(result).map_err(|decode| {
6119 let mut error = Error::decode(decode);
6120 error.operation_id = Some("doc.format.paragraph.setKeepOptions".to_owned());
6121 error.outcome_unknown = true;
6122 error
6123 })
6124 }
6125
6126 pub async fn set_mark_run_props(
6127 &self,
6128 params: &DocFormatParagraphSetMarkRunPropsBoundParams,
6129 ) -> Result<DocFormatParagraphSetMarkRunPropsResult> {
6130 self.set_mark_run_props_with_options(params, InvokeOptions::default())
6131 .await
6132 }
6133 pub async fn set_mark_run_props_with_options(
6134 &self,
6135 params: &DocFormatParagraphSetMarkRunPropsBoundParams,
6136 options: InvokeOptions,
6137 ) -> Result<DocFormatParagraphSetMarkRunPropsResult> {
6138 let params = serde_json::to_value(params)
6139 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6140 let result = self
6141 .invoker
6142 .invoke("doc.format.paragraph.setMarkRunProps", params, options)
6143 .await?;
6144 serde_json::from_value(result).map_err(|decode| {
6145 let mut error = Error::decode(decode);
6146 error.operation_id = Some("doc.format.paragraph.setMarkRunProps".to_owned());
6147 error.outcome_unknown = true;
6148 error
6149 })
6150 }
6151
6152 pub async fn set_numbering(
6153 &self,
6154 params: &DocFormatParagraphSetNumberingBoundParams,
6155 ) -> Result<DocFormatParagraphSetNumberingResult> {
6156 self.set_numbering_with_options(params, InvokeOptions::default())
6157 .await
6158 }
6159 pub async fn set_numbering_with_options(
6160 &self,
6161 params: &DocFormatParagraphSetNumberingBoundParams,
6162 options: InvokeOptions,
6163 ) -> Result<DocFormatParagraphSetNumberingResult> {
6164 let params = serde_json::to_value(params)
6165 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6166 let result = self
6167 .invoker
6168 .invoke("doc.format.paragraph.setNumbering", params, options)
6169 .await?;
6170 serde_json::from_value(result).map_err(|decode| {
6171 let mut error = Error::decode(decode);
6172 error.operation_id = Some("doc.format.paragraph.setNumbering".to_owned());
6173 error.outcome_unknown = true;
6174 error
6175 })
6176 }
6177
6178 pub async fn set_outline_level(
6179 &self,
6180 params: &DocFormatParagraphSetOutlineLevelBoundParams,
6181 ) -> Result<DocFormatParagraphSetOutlineLevelResult> {
6182 self.set_outline_level_with_options(params, InvokeOptions::default())
6183 .await
6184 }
6185 pub async fn set_outline_level_with_options(
6186 &self,
6187 params: &DocFormatParagraphSetOutlineLevelBoundParams,
6188 options: InvokeOptions,
6189 ) -> Result<DocFormatParagraphSetOutlineLevelResult> {
6190 let params = serde_json::to_value(params)
6191 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6192 let result = self
6193 .invoker
6194 .invoke("doc.format.paragraph.setOutlineLevel", params, options)
6195 .await?;
6196 serde_json::from_value(result).map_err(|decode| {
6197 let mut error = Error::decode(decode);
6198 error.operation_id = Some("doc.format.paragraph.setOutlineLevel".to_owned());
6199 error.outcome_unknown = true;
6200 error
6201 })
6202 }
6203
6204 pub async fn set_shading(
6205 &self,
6206 params: &DocFormatParagraphSetShadingBoundParams,
6207 ) -> Result<DocFormatParagraphSetShadingResult> {
6208 self.set_shading_with_options(params, InvokeOptions::default())
6209 .await
6210 }
6211 pub async fn set_shading_with_options(
6212 &self,
6213 params: &DocFormatParagraphSetShadingBoundParams,
6214 options: InvokeOptions,
6215 ) -> Result<DocFormatParagraphSetShadingResult> {
6216 let params = serde_json::to_value(params)
6217 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6218 let result = self
6219 .invoker
6220 .invoke("doc.format.paragraph.setShading", params, options)
6221 .await?;
6222 serde_json::from_value(result).map_err(|decode| {
6223 let mut error = Error::decode(decode);
6224 error.operation_id = Some("doc.format.paragraph.setShading".to_owned());
6225 error.outcome_unknown = true;
6226 error
6227 })
6228 }
6229
6230 pub async fn set_spacing(
6231 &self,
6232 params: &DocFormatParagraphSetSpacingBoundParams,
6233 ) -> Result<DocFormatParagraphSetSpacingResult> {
6234 self.set_spacing_with_options(params, InvokeOptions::default())
6235 .await
6236 }
6237 pub async fn set_spacing_with_options(
6238 &self,
6239 params: &DocFormatParagraphSetSpacingBoundParams,
6240 options: InvokeOptions,
6241 ) -> Result<DocFormatParagraphSetSpacingResult> {
6242 let params = serde_json::to_value(params)
6243 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6244 let result = self
6245 .invoker
6246 .invoke("doc.format.paragraph.setSpacing", params, options)
6247 .await?;
6248 serde_json::from_value(result).map_err(|decode| {
6249 let mut error = Error::decode(decode);
6250 error.operation_id = Some("doc.format.paragraph.setSpacing".to_owned());
6251 error.outcome_unknown = true;
6252 error
6253 })
6254 }
6255
6256 pub async fn set_tab_stop(
6257 &self,
6258 params: &DocFormatParagraphSetTabStopBoundParams,
6259 ) -> Result<DocFormatParagraphSetTabStopResult> {
6260 self.set_tab_stop_with_options(params, InvokeOptions::default())
6261 .await
6262 }
6263 pub async fn set_tab_stop_with_options(
6264 &self,
6265 params: &DocFormatParagraphSetTabStopBoundParams,
6266 options: InvokeOptions,
6267 ) -> Result<DocFormatParagraphSetTabStopResult> {
6268 let params = serde_json::to_value(params)
6269 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6270 let result = self
6271 .invoker
6272 .invoke("doc.format.paragraph.setTabStop", params, options)
6273 .await?;
6274 serde_json::from_value(result).map_err(|decode| {
6275 let mut error = Error::decode(decode);
6276 error.operation_id = Some("doc.format.paragraph.setTabStop".to_owned());
6277 error.outcome_unknown = true;
6278 error
6279 })
6280 }
6281}
6282
6283pub struct DocApiHeaderFooters<'a, I: Invoker> {
6284 invoker: &'a I,
6285}
6286impl<'a, I: Invoker> DocApiHeaderFooters<'a, I> {
6287 pub fn new(invoker: &'a I) -> Self {
6288 Self { invoker }
6289 }
6290 pub fn page_numbers(&self) -> DocApiHeaderFootersPageNumbers<'a, I> {
6291 DocApiHeaderFootersPageNumbers::new(self.invoker)
6292 }
6293 pub fn parts(&self) -> DocApiHeaderFootersParts<'a, I> {
6294 DocApiHeaderFootersParts::new(self.invoker)
6295 }
6296 pub fn refs(&self) -> DocApiHeaderFootersRefs<'a, I> {
6297 DocApiHeaderFootersRefs::new(self.invoker)
6298 }
6299
6300 pub async fn get(
6301 &self,
6302 params: &DocHeaderFootersGetBoundParams,
6303 ) -> Result<DocHeaderFootersGetResult> {
6304 self.get_with_options(params, InvokeOptions::default())
6305 .await
6306 }
6307 pub async fn get_with_options(
6308 &self,
6309 params: &DocHeaderFootersGetBoundParams,
6310 options: InvokeOptions,
6311 ) -> Result<DocHeaderFootersGetResult> {
6312 let params = serde_json::to_value(params)
6313 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6314 let result = self
6315 .invoker
6316 .invoke("doc.headerFooters.get", params, options)
6317 .await?;
6318 serde_json::from_value(result).map_err(|decode| {
6319 let mut error = Error::decode(decode);
6320 error.operation_id = Some("doc.headerFooters.get".to_owned());
6321 error.outcome_unknown = false;
6322 error
6323 })
6324 }
6325
6326 pub async fn list(
6327 &self,
6328 params: &DocHeaderFootersListBoundParams,
6329 ) -> Result<DocHeaderFootersListResult> {
6330 self.list_with_options(params, InvokeOptions::default())
6331 .await
6332 }
6333 pub async fn list_with_options(
6334 &self,
6335 params: &DocHeaderFootersListBoundParams,
6336 options: InvokeOptions,
6337 ) -> Result<DocHeaderFootersListResult> {
6338 let params = serde_json::to_value(params)
6339 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6340 let result = self
6341 .invoker
6342 .invoke("doc.headerFooters.list", params, options)
6343 .await?;
6344 serde_json::from_value(result).map_err(|decode| {
6345 let mut error = Error::decode(decode);
6346 error.operation_id = Some("doc.headerFooters.list".to_owned());
6347 error.outcome_unknown = false;
6348 error
6349 })
6350 }
6351
6352 pub async fn resolve(
6353 &self,
6354 params: &DocHeaderFootersResolveBoundParams,
6355 ) -> Result<DocHeaderFootersResolveResult> {
6356 self.resolve_with_options(params, InvokeOptions::default())
6357 .await
6358 }
6359 pub async fn resolve_with_options(
6360 &self,
6361 params: &DocHeaderFootersResolveBoundParams,
6362 options: InvokeOptions,
6363 ) -> Result<DocHeaderFootersResolveResult> {
6364 let params = serde_json::to_value(params)
6365 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6366 let result = self
6367 .invoker
6368 .invoke("doc.headerFooters.resolve", params, options)
6369 .await?;
6370 serde_json::from_value(result).map_err(|decode| {
6371 let mut error = Error::decode(decode);
6372 error.operation_id = Some("doc.headerFooters.resolve".to_owned());
6373 error.outcome_unknown = false;
6374 error
6375 })
6376 }
6377}
6378
6379pub struct DocApiHeaderFootersPageNumbers<'a, I: Invoker> {
6380 invoker: &'a I,
6381}
6382impl<'a, I: Invoker> DocApiHeaderFootersPageNumbers<'a, I> {
6383 pub fn new(invoker: &'a I) -> Self {
6384 Self { invoker }
6385 }
6386
6387 pub async fn get(
6388 &self,
6389 params: &DocHeaderFootersPageNumbersGetBoundParams,
6390 ) -> Result<DocHeaderFootersPageNumbersGetResult> {
6391 self.get_with_options(params, InvokeOptions::default())
6392 .await
6393 }
6394 pub async fn get_with_options(
6395 &self,
6396 params: &DocHeaderFootersPageNumbersGetBoundParams,
6397 options: InvokeOptions,
6398 ) -> Result<DocHeaderFootersPageNumbersGetResult> {
6399 let params = serde_json::to_value(params)
6400 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6401 let result = self
6402 .invoker
6403 .invoke("doc.headerFooters.pageNumbers.get", params, options)
6404 .await?;
6405 serde_json::from_value(result).map_err(|decode| {
6406 let mut error = Error::decode(decode);
6407 error.operation_id = Some("doc.headerFooters.pageNumbers.get".to_owned());
6408 error.outcome_unknown = false;
6409 error
6410 })
6411 }
6412
6413 pub async fn insert(
6414 &self,
6415 params: &DocHeaderFootersPageNumbersInsertBoundParams,
6416 ) -> Result<DocHeaderFootersPageNumbersInsertResult> {
6417 self.insert_with_options(params, InvokeOptions::default())
6418 .await
6419 }
6420 pub async fn insert_with_options(
6421 &self,
6422 params: &DocHeaderFootersPageNumbersInsertBoundParams,
6423 options: InvokeOptions,
6424 ) -> Result<DocHeaderFootersPageNumbersInsertResult> {
6425 let params = serde_json::to_value(params)
6426 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6427 let result = self
6428 .invoker
6429 .invoke("doc.headerFooters.pageNumbers.insert", params, options)
6430 .await?;
6431 serde_json::from_value(result).map_err(|decode| {
6432 let mut error = Error::decode(decode);
6433 error.operation_id = Some("doc.headerFooters.pageNumbers.insert".to_owned());
6434 error.outcome_unknown = true;
6435 error
6436 })
6437 }
6438
6439 pub async fn remove(
6440 &self,
6441 params: &DocHeaderFootersPageNumbersRemoveBoundParams,
6442 ) -> Result<DocHeaderFootersPageNumbersRemoveResult> {
6443 self.remove_with_options(params, InvokeOptions::default())
6444 .await
6445 }
6446 pub async fn remove_with_options(
6447 &self,
6448 params: &DocHeaderFootersPageNumbersRemoveBoundParams,
6449 options: InvokeOptions,
6450 ) -> Result<DocHeaderFootersPageNumbersRemoveResult> {
6451 let params = serde_json::to_value(params)
6452 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6453 let result = self
6454 .invoker
6455 .invoke("doc.headerFooters.pageNumbers.remove", params, options)
6456 .await?;
6457 serde_json::from_value(result).map_err(|decode| {
6458 let mut error = Error::decode(decode);
6459 error.operation_id = Some("doc.headerFooters.pageNumbers.remove".to_owned());
6460 error.outcome_unknown = true;
6461 error
6462 })
6463 }
6464
6465 pub async fn set(
6466 &self,
6467 params: &DocHeaderFootersPageNumbersSetBoundParams,
6468 ) -> Result<DocHeaderFootersPageNumbersSetResult> {
6469 self.set_with_options(params, InvokeOptions::default())
6470 .await
6471 }
6472 pub async fn set_with_options(
6473 &self,
6474 params: &DocHeaderFootersPageNumbersSetBoundParams,
6475 options: InvokeOptions,
6476 ) -> Result<DocHeaderFootersPageNumbersSetResult> {
6477 let params = serde_json::to_value(params)
6478 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6479 let result = self
6480 .invoker
6481 .invoke("doc.headerFooters.pageNumbers.set", params, options)
6482 .await?;
6483 serde_json::from_value(result).map_err(|decode| {
6484 let mut error = Error::decode(decode);
6485 error.operation_id = Some("doc.headerFooters.pageNumbers.set".to_owned());
6486 error.outcome_unknown = true;
6487 error
6488 })
6489 }
6490}
6491
6492pub struct DocApiHeaderFootersParts<'a, I: Invoker> {
6493 invoker: &'a I,
6494}
6495impl<'a, I: Invoker> DocApiHeaderFootersParts<'a, I> {
6496 pub fn new(invoker: &'a I) -> Self {
6497 Self { invoker }
6498 }
6499
6500 pub async fn create(
6501 &self,
6502 params: &DocHeaderFootersPartsCreateBoundParams,
6503 ) -> Result<DocHeaderFootersPartsCreateResult> {
6504 self.create_with_options(params, InvokeOptions::default())
6505 .await
6506 }
6507 pub async fn create_with_options(
6508 &self,
6509 params: &DocHeaderFootersPartsCreateBoundParams,
6510 options: InvokeOptions,
6511 ) -> Result<DocHeaderFootersPartsCreateResult> {
6512 let params = serde_json::to_value(params)
6513 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6514 let result = self
6515 .invoker
6516 .invoke("doc.headerFooters.parts.create", params, options)
6517 .await?;
6518 serde_json::from_value(result).map_err(|decode| {
6519 let mut error = Error::decode(decode);
6520 error.operation_id = Some("doc.headerFooters.parts.create".to_owned());
6521 error.outcome_unknown = true;
6522 error
6523 })
6524 }
6525
6526 pub async fn delete(
6527 &self,
6528 params: &DocHeaderFootersPartsDeleteBoundParams,
6529 ) -> Result<DocHeaderFootersPartsDeleteResult> {
6530 self.delete_with_options(params, InvokeOptions::default())
6531 .await
6532 }
6533 pub async fn delete_with_options(
6534 &self,
6535 params: &DocHeaderFootersPartsDeleteBoundParams,
6536 options: InvokeOptions,
6537 ) -> Result<DocHeaderFootersPartsDeleteResult> {
6538 let params = serde_json::to_value(params)
6539 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6540 let result = self
6541 .invoker
6542 .invoke("doc.headerFooters.parts.delete", params, options)
6543 .await?;
6544 serde_json::from_value(result).map_err(|decode| {
6545 let mut error = Error::decode(decode);
6546 error.operation_id = Some("doc.headerFooters.parts.delete".to_owned());
6547 error.outcome_unknown = true;
6548 error
6549 })
6550 }
6551
6552 pub async fn list(
6553 &self,
6554 params: &DocHeaderFootersPartsListBoundParams,
6555 ) -> Result<DocHeaderFootersPartsListResult> {
6556 self.list_with_options(params, InvokeOptions::default())
6557 .await
6558 }
6559 pub async fn list_with_options(
6560 &self,
6561 params: &DocHeaderFootersPartsListBoundParams,
6562 options: InvokeOptions,
6563 ) -> Result<DocHeaderFootersPartsListResult> {
6564 let params = serde_json::to_value(params)
6565 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6566 let result = self
6567 .invoker
6568 .invoke("doc.headerFooters.parts.list", params, options)
6569 .await?;
6570 serde_json::from_value(result).map_err(|decode| {
6571 let mut error = Error::decode(decode);
6572 error.operation_id = Some("doc.headerFooters.parts.list".to_owned());
6573 error.outcome_unknown = false;
6574 error
6575 })
6576 }
6577}
6578
6579pub struct DocApiHeaderFootersRefs<'a, I: Invoker> {
6580 invoker: &'a I,
6581}
6582impl<'a, I: Invoker> DocApiHeaderFootersRefs<'a, I> {
6583 pub fn new(invoker: &'a I) -> Self {
6584 Self { invoker }
6585 }
6586
6587 pub async fn clear(
6588 &self,
6589 params: &DocHeaderFootersRefsClearBoundParams,
6590 ) -> Result<DocHeaderFootersRefsClearResult> {
6591 self.clear_with_options(params, InvokeOptions::default())
6592 .await
6593 }
6594 pub async fn clear_with_options(
6595 &self,
6596 params: &DocHeaderFootersRefsClearBoundParams,
6597 options: InvokeOptions,
6598 ) -> Result<DocHeaderFootersRefsClearResult> {
6599 let params = serde_json::to_value(params)
6600 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6601 let result = self
6602 .invoker
6603 .invoke("doc.headerFooters.refs.clear", params, options)
6604 .await?;
6605 serde_json::from_value(result).map_err(|decode| {
6606 let mut error = Error::decode(decode);
6607 error.operation_id = Some("doc.headerFooters.refs.clear".to_owned());
6608 error.outcome_unknown = true;
6609 error
6610 })
6611 }
6612
6613 pub async fn set(
6614 &self,
6615 params: &DocHeaderFootersRefsSetBoundParams,
6616 ) -> Result<DocHeaderFootersRefsSetResult> {
6617 self.set_with_options(params, InvokeOptions::default())
6618 .await
6619 }
6620 pub async fn set_with_options(
6621 &self,
6622 params: &DocHeaderFootersRefsSetBoundParams,
6623 options: InvokeOptions,
6624 ) -> Result<DocHeaderFootersRefsSetResult> {
6625 let params = serde_json::to_value(params)
6626 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6627 let result = self
6628 .invoker
6629 .invoke("doc.headerFooters.refs.set", params, options)
6630 .await?;
6631 serde_json::from_value(result).map_err(|decode| {
6632 let mut error = Error::decode(decode);
6633 error.operation_id = Some("doc.headerFooters.refs.set".to_owned());
6634 error.outcome_unknown = true;
6635 error
6636 })
6637 }
6638
6639 pub async fn set_linked_to_previous(
6640 &self,
6641 params: &DocHeaderFootersRefsSetLinkedToPreviousBoundParams,
6642 ) -> Result<DocHeaderFootersRefsSetLinkedToPreviousResult> {
6643 self.set_linked_to_previous_with_options(params, InvokeOptions::default())
6644 .await
6645 }
6646 pub async fn set_linked_to_previous_with_options(
6647 &self,
6648 params: &DocHeaderFootersRefsSetLinkedToPreviousBoundParams,
6649 options: InvokeOptions,
6650 ) -> Result<DocHeaderFootersRefsSetLinkedToPreviousResult> {
6651 let params = serde_json::to_value(params)
6652 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6653 let result = self
6654 .invoker
6655 .invoke(
6656 "doc.headerFooters.refs.setLinkedToPrevious",
6657 params,
6658 options,
6659 )
6660 .await?;
6661 serde_json::from_value(result).map_err(|decode| {
6662 let mut error = Error::decode(decode);
6663 error.operation_id = Some("doc.headerFooters.refs.setLinkedToPrevious".to_owned());
6664 error.outcome_unknown = true;
6665 error
6666 })
6667 }
6668}
6669
6670pub struct DocApiHistory<'a, I: Invoker> {
6671 invoker: &'a I,
6672}
6673impl<'a, I: Invoker> DocApiHistory<'a, I> {
6674 pub fn new(invoker: &'a I) -> Self {
6675 Self { invoker }
6676 }
6677
6678 pub async fn get(&self, params: &DocHistoryGetBoundParams) -> Result<DocHistoryGetResult> {
6679 self.get_with_options(params, InvokeOptions::default())
6680 .await
6681 }
6682 pub async fn get_with_options(
6683 &self,
6684 params: &DocHistoryGetBoundParams,
6685 options: InvokeOptions,
6686 ) -> Result<DocHistoryGetResult> {
6687 let params = serde_json::to_value(params)
6688 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6689 let result = self
6690 .invoker
6691 .invoke("doc.history.get", params, options)
6692 .await?;
6693 serde_json::from_value(result).map_err(|decode| {
6694 let mut error = Error::decode(decode);
6695 error.operation_id = Some("doc.history.get".to_owned());
6696 error.outcome_unknown = false;
6697 error
6698 })
6699 }
6700
6701 pub async fn redo(&self, params: &DocHistoryRedoBoundParams) -> Result<DocHistoryRedoResult> {
6702 self.redo_with_options(params, InvokeOptions::default())
6703 .await
6704 }
6705 pub async fn redo_with_options(
6706 &self,
6707 params: &DocHistoryRedoBoundParams,
6708 options: InvokeOptions,
6709 ) -> Result<DocHistoryRedoResult> {
6710 let params = serde_json::to_value(params)
6711 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6712 let result = self
6713 .invoker
6714 .invoke("doc.history.redo", params, options)
6715 .await?;
6716 serde_json::from_value(result).map_err(|decode| {
6717 let mut error = Error::decode(decode);
6718 error.operation_id = Some("doc.history.redo".to_owned());
6719 error.outcome_unknown = true;
6720 error
6721 })
6722 }
6723
6724 pub async fn undo(&self, params: &DocHistoryUndoBoundParams) -> Result<DocHistoryUndoResult> {
6725 self.undo_with_options(params, InvokeOptions::default())
6726 .await
6727 }
6728 pub async fn undo_with_options(
6729 &self,
6730 params: &DocHistoryUndoBoundParams,
6731 options: InvokeOptions,
6732 ) -> Result<DocHistoryUndoResult> {
6733 let params = serde_json::to_value(params)
6734 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6735 let result = self
6736 .invoker
6737 .invoke("doc.history.undo", params, options)
6738 .await?;
6739 serde_json::from_value(result).map_err(|decode| {
6740 let mut error = Error::decode(decode);
6741 error.operation_id = Some("doc.history.undo".to_owned());
6742 error.outcome_unknown = true;
6743 error
6744 })
6745 }
6746}
6747
6748pub struct DocApiHyperlinks<'a, I: Invoker> {
6749 invoker: &'a I,
6750}
6751impl<'a, I: Invoker> DocApiHyperlinks<'a, I> {
6752 pub fn new(invoker: &'a I) -> Self {
6753 Self { invoker }
6754 }
6755
6756 pub async fn get(
6757 &self,
6758 params: &DocHyperlinksGetBoundParams,
6759 ) -> Result<DocHyperlinksGetResult> {
6760 self.get_with_options(params, InvokeOptions::default())
6761 .await
6762 }
6763 pub async fn get_with_options(
6764 &self,
6765 params: &DocHyperlinksGetBoundParams,
6766 options: InvokeOptions,
6767 ) -> Result<DocHyperlinksGetResult> {
6768 let params = serde_json::to_value(params)
6769 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6770 let result = self
6771 .invoker
6772 .invoke("doc.hyperlinks.get", params, options)
6773 .await?;
6774 serde_json::from_value(result).map_err(|decode| {
6775 let mut error = Error::decode(decode);
6776 error.operation_id = Some("doc.hyperlinks.get".to_owned());
6777 error.outcome_unknown = false;
6778 error
6779 })
6780 }
6781
6782 pub async fn insert(
6783 &self,
6784 params: &DocHyperlinksInsertBoundParams,
6785 ) -> Result<DocHyperlinksInsertResult> {
6786 self.insert_with_options(params, InvokeOptions::default())
6787 .await
6788 }
6789 pub async fn insert_with_options(
6790 &self,
6791 params: &DocHyperlinksInsertBoundParams,
6792 options: InvokeOptions,
6793 ) -> Result<DocHyperlinksInsertResult> {
6794 let params = serde_json::to_value(params)
6795 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6796 let result = self
6797 .invoker
6798 .invoke("doc.hyperlinks.insert", params, options)
6799 .await?;
6800 serde_json::from_value(result).map_err(|decode| {
6801 let mut error = Error::decode(decode);
6802 error.operation_id = Some("doc.hyperlinks.insert".to_owned());
6803 error.outcome_unknown = true;
6804 error
6805 })
6806 }
6807
6808 pub async fn list(
6809 &self,
6810 params: &DocHyperlinksListBoundParams,
6811 ) -> Result<DocHyperlinksListResult> {
6812 self.list_with_options(params, InvokeOptions::default())
6813 .await
6814 }
6815 pub async fn list_with_options(
6816 &self,
6817 params: &DocHyperlinksListBoundParams,
6818 options: InvokeOptions,
6819 ) -> Result<DocHyperlinksListResult> {
6820 let params = serde_json::to_value(params)
6821 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6822 let result = self
6823 .invoker
6824 .invoke("doc.hyperlinks.list", params, options)
6825 .await?;
6826 serde_json::from_value(result).map_err(|decode| {
6827 let mut error = Error::decode(decode);
6828 error.operation_id = Some("doc.hyperlinks.list".to_owned());
6829 error.outcome_unknown = false;
6830 error
6831 })
6832 }
6833
6834 pub async fn patch(
6835 &self,
6836 params: &DocHyperlinksPatchBoundParams,
6837 ) -> Result<DocHyperlinksPatchResult> {
6838 self.patch_with_options(params, InvokeOptions::default())
6839 .await
6840 }
6841 pub async fn patch_with_options(
6842 &self,
6843 params: &DocHyperlinksPatchBoundParams,
6844 options: InvokeOptions,
6845 ) -> Result<DocHyperlinksPatchResult> {
6846 let params = serde_json::to_value(params)
6847 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6848 let result = self
6849 .invoker
6850 .invoke("doc.hyperlinks.patch", params, options)
6851 .await?;
6852 serde_json::from_value(result).map_err(|decode| {
6853 let mut error = Error::decode(decode);
6854 error.operation_id = Some("doc.hyperlinks.patch".to_owned());
6855 error.outcome_unknown = true;
6856 error
6857 })
6858 }
6859
6860 pub async fn remove(
6861 &self,
6862 params: &DocHyperlinksRemoveBoundParams,
6863 ) -> Result<DocHyperlinksRemoveResult> {
6864 self.remove_with_options(params, InvokeOptions::default())
6865 .await
6866 }
6867 pub async fn remove_with_options(
6868 &self,
6869 params: &DocHyperlinksRemoveBoundParams,
6870 options: InvokeOptions,
6871 ) -> Result<DocHyperlinksRemoveResult> {
6872 let params = serde_json::to_value(params)
6873 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6874 let result = self
6875 .invoker
6876 .invoke("doc.hyperlinks.remove", params, options)
6877 .await?;
6878 serde_json::from_value(result).map_err(|decode| {
6879 let mut error = Error::decode(decode);
6880 error.operation_id = Some("doc.hyperlinks.remove".to_owned());
6881 error.outcome_unknown = true;
6882 error
6883 })
6884 }
6885
6886 pub async fn wrap(
6887 &self,
6888 params: &DocHyperlinksWrapBoundParams,
6889 ) -> Result<DocHyperlinksWrapResult> {
6890 self.wrap_with_options(params, InvokeOptions::default())
6891 .await
6892 }
6893 pub async fn wrap_with_options(
6894 &self,
6895 params: &DocHyperlinksWrapBoundParams,
6896 options: InvokeOptions,
6897 ) -> Result<DocHyperlinksWrapResult> {
6898 let params = serde_json::to_value(params)
6899 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6900 let result = self
6901 .invoker
6902 .invoke("doc.hyperlinks.wrap", params, options)
6903 .await?;
6904 serde_json::from_value(result).map_err(|decode| {
6905 let mut error = Error::decode(decode);
6906 error.operation_id = Some("doc.hyperlinks.wrap".to_owned());
6907 error.outcome_unknown = true;
6908 error
6909 })
6910 }
6911}
6912
6913pub struct DocApiImages<'a, I: Invoker> {
6914 invoker: &'a I,
6915}
6916impl<'a, I: Invoker> DocApiImages<'a, I> {
6917 pub fn new(invoker: &'a I) -> Self {
6918 Self { invoker }
6919 }
6920
6921 pub async fn convert_to_floating(
6922 &self,
6923 params: &DocImagesConvertToFloatingBoundParams,
6924 ) -> Result<DocImagesConvertToFloatingResult> {
6925 self.convert_to_floating_with_options(params, InvokeOptions::default())
6926 .await
6927 }
6928 pub async fn convert_to_floating_with_options(
6929 &self,
6930 params: &DocImagesConvertToFloatingBoundParams,
6931 options: InvokeOptions,
6932 ) -> Result<DocImagesConvertToFloatingResult> {
6933 let params = serde_json::to_value(params)
6934 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6935 let result = self
6936 .invoker
6937 .invoke("doc.images.convertToFloating", params, options)
6938 .await?;
6939 serde_json::from_value(result).map_err(|decode| {
6940 let mut error = Error::decode(decode);
6941 error.operation_id = Some("doc.images.convertToFloating".to_owned());
6942 error.outcome_unknown = true;
6943 error
6944 })
6945 }
6946
6947 pub async fn convert_to_inline(
6948 &self,
6949 params: &DocImagesConvertToInlineBoundParams,
6950 ) -> Result<DocImagesConvertToInlineResult> {
6951 self.convert_to_inline_with_options(params, InvokeOptions::default())
6952 .await
6953 }
6954 pub async fn convert_to_inline_with_options(
6955 &self,
6956 params: &DocImagesConvertToInlineBoundParams,
6957 options: InvokeOptions,
6958 ) -> Result<DocImagesConvertToInlineResult> {
6959 let params = serde_json::to_value(params)
6960 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6961 let result = self
6962 .invoker
6963 .invoke("doc.images.convertToInline", params, options)
6964 .await?;
6965 serde_json::from_value(result).map_err(|decode| {
6966 let mut error = Error::decode(decode);
6967 error.operation_id = Some("doc.images.convertToInline".to_owned());
6968 error.outcome_unknown = true;
6969 error
6970 })
6971 }
6972
6973 pub async fn crop(&self, params: &DocImagesCropBoundParams) -> Result<DocImagesCropResult> {
6974 self.crop_with_options(params, InvokeOptions::default())
6975 .await
6976 }
6977 pub async fn crop_with_options(
6978 &self,
6979 params: &DocImagesCropBoundParams,
6980 options: InvokeOptions,
6981 ) -> Result<DocImagesCropResult> {
6982 let params = serde_json::to_value(params)
6983 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
6984 let result = self
6985 .invoker
6986 .invoke("doc.images.crop", params, options)
6987 .await?;
6988 serde_json::from_value(result).map_err(|decode| {
6989 let mut error = Error::decode(decode);
6990 error.operation_id = Some("doc.images.crop".to_owned());
6991 error.outcome_unknown = true;
6992 error
6993 })
6994 }
6995
6996 pub async fn delete(
6997 &self,
6998 params: &DocImagesDeleteBoundParams,
6999 ) -> Result<DocImagesDeleteResult> {
7000 self.delete_with_options(params, InvokeOptions::default())
7001 .await
7002 }
7003 pub async fn delete_with_options(
7004 &self,
7005 params: &DocImagesDeleteBoundParams,
7006 options: InvokeOptions,
7007 ) -> Result<DocImagesDeleteResult> {
7008 let params = serde_json::to_value(params)
7009 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7010 let result = self
7011 .invoker
7012 .invoke("doc.images.delete", params, options)
7013 .await?;
7014 serde_json::from_value(result).map_err(|decode| {
7015 let mut error = Error::decode(decode);
7016 error.operation_id = Some("doc.images.delete".to_owned());
7017 error.outcome_unknown = true;
7018 error
7019 })
7020 }
7021
7022 pub async fn flip(&self, params: &DocImagesFlipBoundParams) -> Result<DocImagesFlipResult> {
7023 self.flip_with_options(params, InvokeOptions::default())
7024 .await
7025 }
7026 pub async fn flip_with_options(
7027 &self,
7028 params: &DocImagesFlipBoundParams,
7029 options: InvokeOptions,
7030 ) -> Result<DocImagesFlipResult> {
7031 let params = serde_json::to_value(params)
7032 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7033 let result = self
7034 .invoker
7035 .invoke("doc.images.flip", params, options)
7036 .await?;
7037 serde_json::from_value(result).map_err(|decode| {
7038 let mut error = Error::decode(decode);
7039 error.operation_id = Some("doc.images.flip".to_owned());
7040 error.outcome_unknown = true;
7041 error
7042 })
7043 }
7044
7045 pub async fn get(&self, params: &DocImagesGetBoundParams) -> Result<DocImagesGetResult> {
7046 self.get_with_options(params, InvokeOptions::default())
7047 .await
7048 }
7049 pub async fn get_with_options(
7050 &self,
7051 params: &DocImagesGetBoundParams,
7052 options: InvokeOptions,
7053 ) -> Result<DocImagesGetResult> {
7054 let params = serde_json::to_value(params)
7055 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7056 let result = self
7057 .invoker
7058 .invoke("doc.images.get", params, options)
7059 .await?;
7060 serde_json::from_value(result).map_err(|decode| {
7061 let mut error = Error::decode(decode);
7062 error.operation_id = Some("doc.images.get".to_owned());
7063 error.outcome_unknown = false;
7064 error
7065 })
7066 }
7067
7068 pub async fn insert_caption(
7069 &self,
7070 params: &DocImagesInsertCaptionBoundParams,
7071 ) -> Result<DocImagesInsertCaptionResult> {
7072 self.insert_caption_with_options(params, InvokeOptions::default())
7073 .await
7074 }
7075 pub async fn insert_caption_with_options(
7076 &self,
7077 params: &DocImagesInsertCaptionBoundParams,
7078 options: InvokeOptions,
7079 ) -> Result<DocImagesInsertCaptionResult> {
7080 let params = serde_json::to_value(params)
7081 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7082 let result = self
7083 .invoker
7084 .invoke("doc.images.insertCaption", params, options)
7085 .await?;
7086 serde_json::from_value(result).map_err(|decode| {
7087 let mut error = Error::decode(decode);
7088 error.operation_id = Some("doc.images.insertCaption".to_owned());
7089 error.outcome_unknown = true;
7090 error
7091 })
7092 }
7093
7094 pub async fn list(&self, params: &DocImagesListBoundParams) -> Result<DocImagesListResult> {
7095 self.list_with_options(params, InvokeOptions::default())
7096 .await
7097 }
7098 pub async fn list_with_options(
7099 &self,
7100 params: &DocImagesListBoundParams,
7101 options: InvokeOptions,
7102 ) -> Result<DocImagesListResult> {
7103 let params = serde_json::to_value(params)
7104 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7105 let result = self
7106 .invoker
7107 .invoke("doc.images.list", params, options)
7108 .await?;
7109 serde_json::from_value(result).map_err(|decode| {
7110 let mut error = Error::decode(decode);
7111 error.operation_id = Some("doc.images.list".to_owned());
7112 error.outcome_unknown = false;
7113 error
7114 })
7115 }
7116
7117 pub async fn move_(&self, params: &DocImagesMoveBoundParams) -> Result<DocImagesMoveResult> {
7118 self.move_with_options(params, InvokeOptions::default())
7119 .await
7120 }
7121 pub async fn move_with_options(
7122 &self,
7123 params: &DocImagesMoveBoundParams,
7124 options: InvokeOptions,
7125 ) -> Result<DocImagesMoveResult> {
7126 let params = serde_json::to_value(params)
7127 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7128 let result = self
7129 .invoker
7130 .invoke("doc.images.move", params, options)
7131 .await?;
7132 serde_json::from_value(result).map_err(|decode| {
7133 let mut error = Error::decode(decode);
7134 error.operation_id = Some("doc.images.move".to_owned());
7135 error.outcome_unknown = true;
7136 error
7137 })
7138 }
7139
7140 pub async fn remove_caption(
7141 &self,
7142 params: &DocImagesRemoveCaptionBoundParams,
7143 ) -> Result<DocImagesRemoveCaptionResult> {
7144 self.remove_caption_with_options(params, InvokeOptions::default())
7145 .await
7146 }
7147 pub async fn remove_caption_with_options(
7148 &self,
7149 params: &DocImagesRemoveCaptionBoundParams,
7150 options: InvokeOptions,
7151 ) -> Result<DocImagesRemoveCaptionResult> {
7152 let params = serde_json::to_value(params)
7153 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7154 let result = self
7155 .invoker
7156 .invoke("doc.images.removeCaption", params, options)
7157 .await?;
7158 serde_json::from_value(result).map_err(|decode| {
7159 let mut error = Error::decode(decode);
7160 error.operation_id = Some("doc.images.removeCaption".to_owned());
7161 error.outcome_unknown = true;
7162 error
7163 })
7164 }
7165
7166 pub async fn replace_source(
7167 &self,
7168 params: &DocImagesReplaceSourceBoundParams,
7169 ) -> Result<DocImagesReplaceSourceResult> {
7170 self.replace_source_with_options(params, InvokeOptions::default())
7171 .await
7172 }
7173 pub async fn replace_source_with_options(
7174 &self,
7175 params: &DocImagesReplaceSourceBoundParams,
7176 options: InvokeOptions,
7177 ) -> Result<DocImagesReplaceSourceResult> {
7178 let params = serde_json::to_value(params)
7179 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7180 let result = self
7181 .invoker
7182 .invoke("doc.images.replaceSource", params, options)
7183 .await?;
7184 serde_json::from_value(result).map_err(|decode| {
7185 let mut error = Error::decode(decode);
7186 error.operation_id = Some("doc.images.replaceSource".to_owned());
7187 error.outcome_unknown = true;
7188 error
7189 })
7190 }
7191
7192 pub async fn reset_crop(
7193 &self,
7194 params: &DocImagesResetCropBoundParams,
7195 ) -> Result<DocImagesResetCropResult> {
7196 self.reset_crop_with_options(params, InvokeOptions::default())
7197 .await
7198 }
7199 pub async fn reset_crop_with_options(
7200 &self,
7201 params: &DocImagesResetCropBoundParams,
7202 options: InvokeOptions,
7203 ) -> Result<DocImagesResetCropResult> {
7204 let params = serde_json::to_value(params)
7205 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7206 let result = self
7207 .invoker
7208 .invoke("doc.images.resetCrop", params, options)
7209 .await?;
7210 serde_json::from_value(result).map_err(|decode| {
7211 let mut error = Error::decode(decode);
7212 error.operation_id = Some("doc.images.resetCrop".to_owned());
7213 error.outcome_unknown = true;
7214 error
7215 })
7216 }
7217
7218 pub async fn rotate(
7219 &self,
7220 params: &DocImagesRotateBoundParams,
7221 ) -> Result<DocImagesRotateResult> {
7222 self.rotate_with_options(params, InvokeOptions::default())
7223 .await
7224 }
7225 pub async fn rotate_with_options(
7226 &self,
7227 params: &DocImagesRotateBoundParams,
7228 options: InvokeOptions,
7229 ) -> Result<DocImagesRotateResult> {
7230 let params = serde_json::to_value(params)
7231 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7232 let result = self
7233 .invoker
7234 .invoke("doc.images.rotate", params, options)
7235 .await?;
7236 serde_json::from_value(result).map_err(|decode| {
7237 let mut error = Error::decode(decode);
7238 error.operation_id = Some("doc.images.rotate".to_owned());
7239 error.outcome_unknown = true;
7240 error
7241 })
7242 }
7243
7244 pub async fn scale(&self, params: &DocImagesScaleBoundParams) -> Result<DocImagesScaleResult> {
7245 self.scale_with_options(params, InvokeOptions::default())
7246 .await
7247 }
7248 pub async fn scale_with_options(
7249 &self,
7250 params: &DocImagesScaleBoundParams,
7251 options: InvokeOptions,
7252 ) -> Result<DocImagesScaleResult> {
7253 let params = serde_json::to_value(params)
7254 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7255 let result = self
7256 .invoker
7257 .invoke("doc.images.scale", params, options)
7258 .await?;
7259 serde_json::from_value(result).map_err(|decode| {
7260 let mut error = Error::decode(decode);
7261 error.operation_id = Some("doc.images.scale".to_owned());
7262 error.outcome_unknown = true;
7263 error
7264 })
7265 }
7266
7267 pub async fn set_alt_text(
7268 &self,
7269 params: &DocImagesSetAltTextBoundParams,
7270 ) -> Result<DocImagesSetAltTextResult> {
7271 self.set_alt_text_with_options(params, InvokeOptions::default())
7272 .await
7273 }
7274 pub async fn set_alt_text_with_options(
7275 &self,
7276 params: &DocImagesSetAltTextBoundParams,
7277 options: InvokeOptions,
7278 ) -> Result<DocImagesSetAltTextResult> {
7279 let params = serde_json::to_value(params)
7280 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7281 let result = self
7282 .invoker
7283 .invoke("doc.images.setAltText", params, options)
7284 .await?;
7285 serde_json::from_value(result).map_err(|decode| {
7286 let mut error = Error::decode(decode);
7287 error.operation_id = Some("doc.images.setAltText".to_owned());
7288 error.outcome_unknown = true;
7289 error
7290 })
7291 }
7292
7293 pub async fn set_anchor_options(
7294 &self,
7295 params: &DocImagesSetAnchorOptionsBoundParams,
7296 ) -> Result<DocImagesSetAnchorOptionsResult> {
7297 self.set_anchor_options_with_options(params, InvokeOptions::default())
7298 .await
7299 }
7300 pub async fn set_anchor_options_with_options(
7301 &self,
7302 params: &DocImagesSetAnchorOptionsBoundParams,
7303 options: InvokeOptions,
7304 ) -> Result<DocImagesSetAnchorOptionsResult> {
7305 let params = serde_json::to_value(params)
7306 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7307 let result = self
7308 .invoker
7309 .invoke("doc.images.setAnchorOptions", params, options)
7310 .await?;
7311 serde_json::from_value(result).map_err(|decode| {
7312 let mut error = Error::decode(decode);
7313 error.operation_id = Some("doc.images.setAnchorOptions".to_owned());
7314 error.outcome_unknown = true;
7315 error
7316 })
7317 }
7318
7319 pub async fn set_decorative(
7320 &self,
7321 params: &DocImagesSetDecorativeBoundParams,
7322 ) -> Result<DocImagesSetDecorativeResult> {
7323 self.set_decorative_with_options(params, InvokeOptions::default())
7324 .await
7325 }
7326 pub async fn set_decorative_with_options(
7327 &self,
7328 params: &DocImagesSetDecorativeBoundParams,
7329 options: InvokeOptions,
7330 ) -> Result<DocImagesSetDecorativeResult> {
7331 let params = serde_json::to_value(params)
7332 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7333 let result = self
7334 .invoker
7335 .invoke("doc.images.setDecorative", params, options)
7336 .await?;
7337 serde_json::from_value(result).map_err(|decode| {
7338 let mut error = Error::decode(decode);
7339 error.operation_id = Some("doc.images.setDecorative".to_owned());
7340 error.outcome_unknown = true;
7341 error
7342 })
7343 }
7344
7345 pub async fn set_hyperlink(
7346 &self,
7347 params: &DocImagesSetHyperlinkBoundParams,
7348 ) -> Result<DocImagesSetHyperlinkResult> {
7349 self.set_hyperlink_with_options(params, InvokeOptions::default())
7350 .await
7351 }
7352 pub async fn set_hyperlink_with_options(
7353 &self,
7354 params: &DocImagesSetHyperlinkBoundParams,
7355 options: InvokeOptions,
7356 ) -> Result<DocImagesSetHyperlinkResult> {
7357 let params = serde_json::to_value(params)
7358 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7359 let result = self
7360 .invoker
7361 .invoke("doc.images.setHyperlink", params, options)
7362 .await?;
7363 serde_json::from_value(result).map_err(|decode| {
7364 let mut error = Error::decode(decode);
7365 error.operation_id = Some("doc.images.setHyperlink".to_owned());
7366 error.outcome_unknown = true;
7367 error
7368 })
7369 }
7370
7371 pub async fn set_lock_aspect_ratio(
7372 &self,
7373 params: &DocImagesSetLockAspectRatioBoundParams,
7374 ) -> Result<DocImagesSetLockAspectRatioResult> {
7375 self.set_lock_aspect_ratio_with_options(params, InvokeOptions::default())
7376 .await
7377 }
7378 pub async fn set_lock_aspect_ratio_with_options(
7379 &self,
7380 params: &DocImagesSetLockAspectRatioBoundParams,
7381 options: InvokeOptions,
7382 ) -> Result<DocImagesSetLockAspectRatioResult> {
7383 let params = serde_json::to_value(params)
7384 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7385 let result = self
7386 .invoker
7387 .invoke("doc.images.setLockAspectRatio", params, options)
7388 .await?;
7389 serde_json::from_value(result).map_err(|decode| {
7390 let mut error = Error::decode(decode);
7391 error.operation_id = Some("doc.images.setLockAspectRatio".to_owned());
7392 error.outcome_unknown = true;
7393 error
7394 })
7395 }
7396
7397 pub async fn set_name(
7398 &self,
7399 params: &DocImagesSetNameBoundParams,
7400 ) -> Result<DocImagesSetNameResult> {
7401 self.set_name_with_options(params, InvokeOptions::default())
7402 .await
7403 }
7404 pub async fn set_name_with_options(
7405 &self,
7406 params: &DocImagesSetNameBoundParams,
7407 options: InvokeOptions,
7408 ) -> Result<DocImagesSetNameResult> {
7409 let params = serde_json::to_value(params)
7410 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7411 let result = self
7412 .invoker
7413 .invoke("doc.images.setName", params, options)
7414 .await?;
7415 serde_json::from_value(result).map_err(|decode| {
7416 let mut error = Error::decode(decode);
7417 error.operation_id = Some("doc.images.setName".to_owned());
7418 error.outcome_unknown = true;
7419 error
7420 })
7421 }
7422
7423 pub async fn set_position(
7424 &self,
7425 params: &DocImagesSetPositionBoundParams,
7426 ) -> Result<DocImagesSetPositionResult> {
7427 self.set_position_with_options(params, InvokeOptions::default())
7428 .await
7429 }
7430 pub async fn set_position_with_options(
7431 &self,
7432 params: &DocImagesSetPositionBoundParams,
7433 options: InvokeOptions,
7434 ) -> Result<DocImagesSetPositionResult> {
7435 let params = serde_json::to_value(params)
7436 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7437 let result = self
7438 .invoker
7439 .invoke("doc.images.setPosition", params, options)
7440 .await?;
7441 serde_json::from_value(result).map_err(|decode| {
7442 let mut error = Error::decode(decode);
7443 error.operation_id = Some("doc.images.setPosition".to_owned());
7444 error.outcome_unknown = true;
7445 error
7446 })
7447 }
7448
7449 pub async fn set_size(
7450 &self,
7451 params: &DocImagesSetSizeBoundParams,
7452 ) -> Result<DocImagesSetSizeResult> {
7453 self.set_size_with_options(params, InvokeOptions::default())
7454 .await
7455 }
7456 pub async fn set_size_with_options(
7457 &self,
7458 params: &DocImagesSetSizeBoundParams,
7459 options: InvokeOptions,
7460 ) -> Result<DocImagesSetSizeResult> {
7461 let params = serde_json::to_value(params)
7462 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7463 let result = self
7464 .invoker
7465 .invoke("doc.images.setSize", params, options)
7466 .await?;
7467 serde_json::from_value(result).map_err(|decode| {
7468 let mut error = Error::decode(decode);
7469 error.operation_id = Some("doc.images.setSize".to_owned());
7470 error.outcome_unknown = true;
7471 error
7472 })
7473 }
7474
7475 pub async fn set_wrap_distances(
7476 &self,
7477 params: &DocImagesSetWrapDistancesBoundParams,
7478 ) -> Result<DocImagesSetWrapDistancesResult> {
7479 self.set_wrap_distances_with_options(params, InvokeOptions::default())
7480 .await
7481 }
7482 pub async fn set_wrap_distances_with_options(
7483 &self,
7484 params: &DocImagesSetWrapDistancesBoundParams,
7485 options: InvokeOptions,
7486 ) -> Result<DocImagesSetWrapDistancesResult> {
7487 let params = serde_json::to_value(params)
7488 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7489 let result = self
7490 .invoker
7491 .invoke("doc.images.setWrapDistances", params, options)
7492 .await?;
7493 serde_json::from_value(result).map_err(|decode| {
7494 let mut error = Error::decode(decode);
7495 error.operation_id = Some("doc.images.setWrapDistances".to_owned());
7496 error.outcome_unknown = true;
7497 error
7498 })
7499 }
7500
7501 pub async fn set_wrap_side(
7502 &self,
7503 params: &DocImagesSetWrapSideBoundParams,
7504 ) -> Result<DocImagesSetWrapSideResult> {
7505 self.set_wrap_side_with_options(params, InvokeOptions::default())
7506 .await
7507 }
7508 pub async fn set_wrap_side_with_options(
7509 &self,
7510 params: &DocImagesSetWrapSideBoundParams,
7511 options: InvokeOptions,
7512 ) -> Result<DocImagesSetWrapSideResult> {
7513 let params = serde_json::to_value(params)
7514 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7515 let result = self
7516 .invoker
7517 .invoke("doc.images.setWrapSide", params, options)
7518 .await?;
7519 serde_json::from_value(result).map_err(|decode| {
7520 let mut error = Error::decode(decode);
7521 error.operation_id = Some("doc.images.setWrapSide".to_owned());
7522 error.outcome_unknown = true;
7523 error
7524 })
7525 }
7526
7527 pub async fn set_wrap_type(
7528 &self,
7529 params: &DocImagesSetWrapTypeBoundParams,
7530 ) -> Result<DocImagesSetWrapTypeResult> {
7531 self.set_wrap_type_with_options(params, InvokeOptions::default())
7532 .await
7533 }
7534 pub async fn set_wrap_type_with_options(
7535 &self,
7536 params: &DocImagesSetWrapTypeBoundParams,
7537 options: InvokeOptions,
7538 ) -> Result<DocImagesSetWrapTypeResult> {
7539 let params = serde_json::to_value(params)
7540 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7541 let result = self
7542 .invoker
7543 .invoke("doc.images.setWrapType", params, options)
7544 .await?;
7545 serde_json::from_value(result).map_err(|decode| {
7546 let mut error = Error::decode(decode);
7547 error.operation_id = Some("doc.images.setWrapType".to_owned());
7548 error.outcome_unknown = true;
7549 error
7550 })
7551 }
7552
7553 pub async fn set_z_order(
7554 &self,
7555 params: &DocImagesSetZOrderBoundParams,
7556 ) -> Result<DocImagesSetZOrderResult> {
7557 self.set_z_order_with_options(params, InvokeOptions::default())
7558 .await
7559 }
7560 pub async fn set_z_order_with_options(
7561 &self,
7562 params: &DocImagesSetZOrderBoundParams,
7563 options: InvokeOptions,
7564 ) -> Result<DocImagesSetZOrderResult> {
7565 let params = serde_json::to_value(params)
7566 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7567 let result = self
7568 .invoker
7569 .invoke("doc.images.setZOrder", params, options)
7570 .await?;
7571 serde_json::from_value(result).map_err(|decode| {
7572 let mut error = Error::decode(decode);
7573 error.operation_id = Some("doc.images.setZOrder".to_owned());
7574 error.outcome_unknown = true;
7575 error
7576 })
7577 }
7578
7579 pub async fn update_caption(
7580 &self,
7581 params: &DocImagesUpdateCaptionBoundParams,
7582 ) -> Result<DocImagesUpdateCaptionResult> {
7583 self.update_caption_with_options(params, InvokeOptions::default())
7584 .await
7585 }
7586 pub async fn update_caption_with_options(
7587 &self,
7588 params: &DocImagesUpdateCaptionBoundParams,
7589 options: InvokeOptions,
7590 ) -> Result<DocImagesUpdateCaptionResult> {
7591 let params = serde_json::to_value(params)
7592 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7593 let result = self
7594 .invoker
7595 .invoke("doc.images.updateCaption", params, options)
7596 .await?;
7597 serde_json::from_value(result).map_err(|decode| {
7598 let mut error = Error::decode(decode);
7599 error.operation_id = Some("doc.images.updateCaption".to_owned());
7600 error.outcome_unknown = true;
7601 error
7602 })
7603 }
7604}
7605
7606pub struct DocApiIndex<'a, I: Invoker> {
7607 invoker: &'a I,
7608}
7609impl<'a, I: Invoker> DocApiIndex<'a, I> {
7610 pub fn new(invoker: &'a I) -> Self {
7611 Self { invoker }
7612 }
7613 pub fn entries(&self) -> DocApiIndexEntries<'a, I> {
7614 DocApiIndexEntries::new(self.invoker)
7615 }
7616
7617 pub async fn configure(
7618 &self,
7619 params: &DocIndexConfigureBoundParams,
7620 ) -> Result<DocIndexConfigureResult> {
7621 self.configure_with_options(params, InvokeOptions::default())
7622 .await
7623 }
7624 pub async fn configure_with_options(
7625 &self,
7626 params: &DocIndexConfigureBoundParams,
7627 options: InvokeOptions,
7628 ) -> Result<DocIndexConfigureResult> {
7629 let params = serde_json::to_value(params)
7630 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7631 let result = self
7632 .invoker
7633 .invoke("doc.index.configure", params, options)
7634 .await?;
7635 serde_json::from_value(result).map_err(|decode| {
7636 let mut error = Error::decode(decode);
7637 error.operation_id = Some("doc.index.configure".to_owned());
7638 error.outcome_unknown = true;
7639 error
7640 })
7641 }
7642
7643 pub async fn get(&self, params: &DocIndexGetBoundParams) -> Result<DocIndexGetResult> {
7644 self.get_with_options(params, InvokeOptions::default())
7645 .await
7646 }
7647 pub async fn get_with_options(
7648 &self,
7649 params: &DocIndexGetBoundParams,
7650 options: InvokeOptions,
7651 ) -> Result<DocIndexGetResult> {
7652 let params = serde_json::to_value(params)
7653 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7654 let result = self
7655 .invoker
7656 .invoke("doc.index.get", params, options)
7657 .await?;
7658 serde_json::from_value(result).map_err(|decode| {
7659 let mut error = Error::decode(decode);
7660 error.operation_id = Some("doc.index.get".to_owned());
7661 error.outcome_unknown = false;
7662 error
7663 })
7664 }
7665
7666 pub async fn insert(&self, params: &DocIndexInsertBoundParams) -> Result<DocIndexInsertResult> {
7667 self.insert_with_options(params, InvokeOptions::default())
7668 .await
7669 }
7670 pub async fn insert_with_options(
7671 &self,
7672 params: &DocIndexInsertBoundParams,
7673 options: InvokeOptions,
7674 ) -> Result<DocIndexInsertResult> {
7675 let params = serde_json::to_value(params)
7676 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7677 let result = self
7678 .invoker
7679 .invoke("doc.index.insert", params, options)
7680 .await?;
7681 serde_json::from_value(result).map_err(|decode| {
7682 let mut error = Error::decode(decode);
7683 error.operation_id = Some("doc.index.insert".to_owned());
7684 error.outcome_unknown = true;
7685 error
7686 })
7687 }
7688
7689 pub async fn list(&self, params: &DocIndexListBoundParams) -> Result<DocIndexListResult> {
7690 self.list_with_options(params, InvokeOptions::default())
7691 .await
7692 }
7693 pub async fn list_with_options(
7694 &self,
7695 params: &DocIndexListBoundParams,
7696 options: InvokeOptions,
7697 ) -> Result<DocIndexListResult> {
7698 let params = serde_json::to_value(params)
7699 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7700 let result = self
7701 .invoker
7702 .invoke("doc.index.list", params, options)
7703 .await?;
7704 serde_json::from_value(result).map_err(|decode| {
7705 let mut error = Error::decode(decode);
7706 error.operation_id = Some("doc.index.list".to_owned());
7707 error.outcome_unknown = false;
7708 error
7709 })
7710 }
7711
7712 pub async fn rebuild(
7713 &self,
7714 params: &DocIndexRebuildBoundParams,
7715 ) -> Result<DocIndexRebuildResult> {
7716 self.rebuild_with_options(params, InvokeOptions::default())
7717 .await
7718 }
7719 pub async fn rebuild_with_options(
7720 &self,
7721 params: &DocIndexRebuildBoundParams,
7722 options: InvokeOptions,
7723 ) -> Result<DocIndexRebuildResult> {
7724 let params = serde_json::to_value(params)
7725 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7726 let result = self
7727 .invoker
7728 .invoke("doc.index.rebuild", params, options)
7729 .await?;
7730 serde_json::from_value(result).map_err(|decode| {
7731 let mut error = Error::decode(decode);
7732 error.operation_id = Some("doc.index.rebuild".to_owned());
7733 error.outcome_unknown = true;
7734 error
7735 })
7736 }
7737
7738 pub async fn remove(&self, params: &DocIndexRemoveBoundParams) -> Result<DocIndexRemoveResult> {
7739 self.remove_with_options(params, InvokeOptions::default())
7740 .await
7741 }
7742 pub async fn remove_with_options(
7743 &self,
7744 params: &DocIndexRemoveBoundParams,
7745 options: InvokeOptions,
7746 ) -> Result<DocIndexRemoveResult> {
7747 let params = serde_json::to_value(params)
7748 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7749 let result = self
7750 .invoker
7751 .invoke("doc.index.remove", params, options)
7752 .await?;
7753 serde_json::from_value(result).map_err(|decode| {
7754 let mut error = Error::decode(decode);
7755 error.operation_id = Some("doc.index.remove".to_owned());
7756 error.outcome_unknown = true;
7757 error
7758 })
7759 }
7760}
7761
7762pub struct DocApiIndexEntries<'a, I: Invoker> {
7763 invoker: &'a I,
7764}
7765impl<'a, I: Invoker> DocApiIndexEntries<'a, I> {
7766 pub fn new(invoker: &'a I) -> Self {
7767 Self { invoker }
7768 }
7769
7770 pub async fn get(
7771 &self,
7772 params: &DocIndexEntriesGetBoundParams,
7773 ) -> Result<DocIndexEntriesGetResult> {
7774 self.get_with_options(params, InvokeOptions::default())
7775 .await
7776 }
7777 pub async fn get_with_options(
7778 &self,
7779 params: &DocIndexEntriesGetBoundParams,
7780 options: InvokeOptions,
7781 ) -> Result<DocIndexEntriesGetResult> {
7782 let params = serde_json::to_value(params)
7783 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7784 let result = self
7785 .invoker
7786 .invoke("doc.index.entries.get", params, options)
7787 .await?;
7788 serde_json::from_value(result).map_err(|decode| {
7789 let mut error = Error::decode(decode);
7790 error.operation_id = Some("doc.index.entries.get".to_owned());
7791 error.outcome_unknown = false;
7792 error
7793 })
7794 }
7795
7796 pub async fn insert(
7797 &self,
7798 params: &DocIndexEntriesInsertBoundParams,
7799 ) -> Result<DocIndexEntriesInsertResult> {
7800 self.insert_with_options(params, InvokeOptions::default())
7801 .await
7802 }
7803 pub async fn insert_with_options(
7804 &self,
7805 params: &DocIndexEntriesInsertBoundParams,
7806 options: InvokeOptions,
7807 ) -> Result<DocIndexEntriesInsertResult> {
7808 let params = serde_json::to_value(params)
7809 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7810 let result = self
7811 .invoker
7812 .invoke("doc.index.entries.insert", params, options)
7813 .await?;
7814 serde_json::from_value(result).map_err(|decode| {
7815 let mut error = Error::decode(decode);
7816 error.operation_id = Some("doc.index.entries.insert".to_owned());
7817 error.outcome_unknown = true;
7818 error
7819 })
7820 }
7821
7822 pub async fn list(
7823 &self,
7824 params: &DocIndexEntriesListBoundParams,
7825 ) -> Result<DocIndexEntriesListResult> {
7826 self.list_with_options(params, InvokeOptions::default())
7827 .await
7828 }
7829 pub async fn list_with_options(
7830 &self,
7831 params: &DocIndexEntriesListBoundParams,
7832 options: InvokeOptions,
7833 ) -> Result<DocIndexEntriesListResult> {
7834 let params = serde_json::to_value(params)
7835 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7836 let result = self
7837 .invoker
7838 .invoke("doc.index.entries.list", params, options)
7839 .await?;
7840 serde_json::from_value(result).map_err(|decode| {
7841 let mut error = Error::decode(decode);
7842 error.operation_id = Some("doc.index.entries.list".to_owned());
7843 error.outcome_unknown = false;
7844 error
7845 })
7846 }
7847
7848 pub async fn remove(
7849 &self,
7850 params: &DocIndexEntriesRemoveBoundParams,
7851 ) -> Result<DocIndexEntriesRemoveResult> {
7852 self.remove_with_options(params, InvokeOptions::default())
7853 .await
7854 }
7855 pub async fn remove_with_options(
7856 &self,
7857 params: &DocIndexEntriesRemoveBoundParams,
7858 options: InvokeOptions,
7859 ) -> Result<DocIndexEntriesRemoveResult> {
7860 let params = serde_json::to_value(params)
7861 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7862 let result = self
7863 .invoker
7864 .invoke("doc.index.entries.remove", params, options)
7865 .await?;
7866 serde_json::from_value(result).map_err(|decode| {
7867 let mut error = Error::decode(decode);
7868 error.operation_id = Some("doc.index.entries.remove".to_owned());
7869 error.outcome_unknown = true;
7870 error
7871 })
7872 }
7873
7874 pub async fn update(
7875 &self,
7876 params: &DocIndexEntriesUpdateBoundParams,
7877 ) -> Result<DocIndexEntriesUpdateResult> {
7878 self.update_with_options(params, InvokeOptions::default())
7879 .await
7880 }
7881 pub async fn update_with_options(
7882 &self,
7883 params: &DocIndexEntriesUpdateBoundParams,
7884 options: InvokeOptions,
7885 ) -> Result<DocIndexEntriesUpdateResult> {
7886 let params = serde_json::to_value(params)
7887 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7888 let result = self
7889 .invoker
7890 .invoke("doc.index.entries.update", params, options)
7891 .await?;
7892 serde_json::from_value(result).map_err(|decode| {
7893 let mut error = Error::decode(decode);
7894 error.operation_id = Some("doc.index.entries.update".to_owned());
7895 error.outcome_unknown = true;
7896 error
7897 })
7898 }
7899}
7900
7901pub struct DocApiLists<'a, I: Invoker> {
7902 invoker: &'a I,
7903}
7904impl<'a, I: Invoker> DocApiLists<'a, I> {
7905 pub fn new(invoker: &'a I) -> Self {
7906 Self { invoker }
7907 }
7908
7909 pub async fn apply(&self, params: &DocListsApplyBoundParams) -> Result<DocListsApplyResult> {
7910 self.apply_with_options(params, InvokeOptions::default())
7911 .await
7912 }
7913 pub async fn apply_with_options(
7914 &self,
7915 params: &DocListsApplyBoundParams,
7916 options: InvokeOptions,
7917 ) -> Result<DocListsApplyResult> {
7918 let params = serde_json::to_value(params)
7919 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7920 let result = self
7921 .invoker
7922 .invoke("doc.lists.apply", params, options)
7923 .await?;
7924 serde_json::from_value(result).map_err(|decode| {
7925 let mut error = Error::decode(decode);
7926 error.operation_id = Some("doc.lists.apply".to_owned());
7927 error.outcome_unknown = true;
7928 error
7929 })
7930 }
7931
7932 pub async fn apply_preset(
7933 &self,
7934 params: &DocListsApplyPresetBoundParams,
7935 ) -> Result<DocListsApplyPresetResult> {
7936 self.apply_preset_with_options(params, InvokeOptions::default())
7937 .await
7938 }
7939 pub async fn apply_preset_with_options(
7940 &self,
7941 params: &DocListsApplyPresetBoundParams,
7942 options: InvokeOptions,
7943 ) -> Result<DocListsApplyPresetResult> {
7944 let params = serde_json::to_value(params)
7945 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7946 let result = self
7947 .invoker
7948 .invoke("doc.lists.applyPreset", params, options)
7949 .await?;
7950 serde_json::from_value(result).map_err(|decode| {
7951 let mut error = Error::decode(decode);
7952 error.operation_id = Some("doc.lists.applyPreset".to_owned());
7953 error.outcome_unknown = true;
7954 error
7955 })
7956 }
7957
7958 pub async fn apply_style(
7959 &self,
7960 params: &DocListsApplyStyleBoundParams,
7961 ) -> Result<DocListsApplyStyleResult> {
7962 self.apply_style_with_options(params, InvokeOptions::default())
7963 .await
7964 }
7965 pub async fn apply_style_with_options(
7966 &self,
7967 params: &DocListsApplyStyleBoundParams,
7968 options: InvokeOptions,
7969 ) -> Result<DocListsApplyStyleResult> {
7970 let params = serde_json::to_value(params)
7971 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7972 let result = self
7973 .invoker
7974 .invoke("doc.lists.applyStyle", params, options)
7975 .await?;
7976 serde_json::from_value(result).map_err(|decode| {
7977 let mut error = Error::decode(decode);
7978 error.operation_id = Some("doc.lists.applyStyle".to_owned());
7979 error.outcome_unknown = true;
7980 error
7981 })
7982 }
7983
7984 pub async fn apply_template(
7985 &self,
7986 params: &DocListsApplyTemplateBoundParams,
7987 ) -> Result<DocListsApplyTemplateResult> {
7988 self.apply_template_with_options(params, InvokeOptions::default())
7989 .await
7990 }
7991 pub async fn apply_template_with_options(
7992 &self,
7993 params: &DocListsApplyTemplateBoundParams,
7994 options: InvokeOptions,
7995 ) -> Result<DocListsApplyTemplateResult> {
7996 let params = serde_json::to_value(params)
7997 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
7998 let result = self
7999 .invoker
8000 .invoke("doc.lists.applyTemplate", params, options)
8001 .await?;
8002 serde_json::from_value(result).map_err(|decode| {
8003 let mut error = Error::decode(decode);
8004 error.operation_id = Some("doc.lists.applyTemplate".to_owned());
8005 error.outcome_unknown = true;
8006 error
8007 })
8008 }
8009
8010 pub async fn attach(&self, params: &DocListsAttachBoundParams) -> Result<DocListsAttachResult> {
8011 self.attach_with_options(params, InvokeOptions::default())
8012 .await
8013 }
8014 pub async fn attach_with_options(
8015 &self,
8016 params: &DocListsAttachBoundParams,
8017 options: InvokeOptions,
8018 ) -> Result<DocListsAttachResult> {
8019 let params = serde_json::to_value(params)
8020 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8021 let result = self
8022 .invoker
8023 .invoke("doc.lists.attach", params, options)
8024 .await?;
8025 serde_json::from_value(result).map_err(|decode| {
8026 let mut error = Error::decode(decode);
8027 error.operation_id = Some("doc.lists.attach".to_owned());
8028 error.outcome_unknown = true;
8029 error
8030 })
8031 }
8032
8033 pub async fn can_continue_previous(
8034 &self,
8035 params: &DocListsCanContinuePreviousBoundParams,
8036 ) -> Result<DocListsCanContinuePreviousResult> {
8037 self.can_continue_previous_with_options(params, InvokeOptions::default())
8038 .await
8039 }
8040 pub async fn can_continue_previous_with_options(
8041 &self,
8042 params: &DocListsCanContinuePreviousBoundParams,
8043 options: InvokeOptions,
8044 ) -> Result<DocListsCanContinuePreviousResult> {
8045 let params = serde_json::to_value(params)
8046 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8047 let result = self
8048 .invoker
8049 .invoke("doc.lists.canContinuePrevious", params, options)
8050 .await?;
8051 serde_json::from_value(result).map_err(|decode| {
8052 let mut error = Error::decode(decode);
8053 error.operation_id = Some("doc.lists.canContinuePrevious".to_owned());
8054 error.outcome_unknown = false;
8055 error
8056 })
8057 }
8058
8059 pub async fn can_join(
8060 &self,
8061 params: &DocListsCanJoinBoundParams,
8062 ) -> Result<DocListsCanJoinResult> {
8063 self.can_join_with_options(params, InvokeOptions::default())
8064 .await
8065 }
8066 pub async fn can_join_with_options(
8067 &self,
8068 params: &DocListsCanJoinBoundParams,
8069 options: InvokeOptions,
8070 ) -> Result<DocListsCanJoinResult> {
8071 let params = serde_json::to_value(params)
8072 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8073 let result = self
8074 .invoker
8075 .invoke("doc.lists.canJoin", params, options)
8076 .await?;
8077 serde_json::from_value(result).map_err(|decode| {
8078 let mut error = Error::decode(decode);
8079 error.operation_id = Some("doc.lists.canJoin".to_owned());
8080 error.outcome_unknown = false;
8081 error
8082 })
8083 }
8084
8085 pub async fn capture_template(
8086 &self,
8087 params: &DocListsCaptureTemplateBoundParams,
8088 ) -> Result<DocListsCaptureTemplateResult> {
8089 self.capture_template_with_options(params, InvokeOptions::default())
8090 .await
8091 }
8092 pub async fn capture_template_with_options(
8093 &self,
8094 params: &DocListsCaptureTemplateBoundParams,
8095 options: InvokeOptions,
8096 ) -> Result<DocListsCaptureTemplateResult> {
8097 let params = serde_json::to_value(params)
8098 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8099 let result = self
8100 .invoker
8101 .invoke("doc.lists.captureTemplate", params, options)
8102 .await?;
8103 serde_json::from_value(result).map_err(|decode| {
8104 let mut error = Error::decode(decode);
8105 error.operation_id = Some("doc.lists.captureTemplate".to_owned());
8106 error.outcome_unknown = false;
8107 error
8108 })
8109 }
8110
8111 pub async fn clear_level_overrides(
8112 &self,
8113 params: &DocListsClearLevelOverridesBoundParams,
8114 ) -> Result<DocListsClearLevelOverridesResult> {
8115 self.clear_level_overrides_with_options(params, InvokeOptions::default())
8116 .await
8117 }
8118 pub async fn clear_level_overrides_with_options(
8119 &self,
8120 params: &DocListsClearLevelOverridesBoundParams,
8121 options: InvokeOptions,
8122 ) -> Result<DocListsClearLevelOverridesResult> {
8123 let params = serde_json::to_value(params)
8124 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8125 let result = self
8126 .invoker
8127 .invoke("doc.lists.clearLevelOverrides", params, options)
8128 .await?;
8129 serde_json::from_value(result).map_err(|decode| {
8130 let mut error = Error::decode(decode);
8131 error.operation_id = Some("doc.lists.clearLevelOverrides".to_owned());
8132 error.outcome_unknown = true;
8133 error
8134 })
8135 }
8136
8137 pub async fn continue_(
8138 &self,
8139 params: &DocListsContinueBoundParams,
8140 ) -> Result<DocListsContinueResult> {
8141 self.continue_with_options(params, InvokeOptions::default())
8142 .await
8143 }
8144 pub async fn continue_with_options(
8145 &self,
8146 params: &DocListsContinueBoundParams,
8147 options: InvokeOptions,
8148 ) -> Result<DocListsContinueResult> {
8149 let params = serde_json::to_value(params)
8150 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8151 let result = self
8152 .invoker
8153 .invoke("doc.lists.continue", params, options)
8154 .await?;
8155 serde_json::from_value(result).map_err(|decode| {
8156 let mut error = Error::decode(decode);
8157 error.operation_id = Some("doc.lists.continue".to_owned());
8158 error.outcome_unknown = true;
8159 error
8160 })
8161 }
8162
8163 pub async fn continue_previous(
8164 &self,
8165 params: &DocListsContinuePreviousBoundParams,
8166 ) -> Result<DocListsContinuePreviousResult> {
8167 self.continue_previous_with_options(params, InvokeOptions::default())
8168 .await
8169 }
8170 pub async fn continue_previous_with_options(
8171 &self,
8172 params: &DocListsContinuePreviousBoundParams,
8173 options: InvokeOptions,
8174 ) -> Result<DocListsContinuePreviousResult> {
8175 let params = serde_json::to_value(params)
8176 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8177 let result = self
8178 .invoker
8179 .invoke("doc.lists.continuePrevious", params, options)
8180 .await?;
8181 serde_json::from_value(result).map_err(|decode| {
8182 let mut error = Error::decode(decode);
8183 error.operation_id = Some("doc.lists.continuePrevious".to_owned());
8184 error.outcome_unknown = true;
8185 error
8186 })
8187 }
8188
8189 pub async fn convert_to_text(
8190 &self,
8191 params: &DocListsConvertToTextBoundParams,
8192 ) -> Result<DocListsConvertToTextResult> {
8193 self.convert_to_text_with_options(params, InvokeOptions::default())
8194 .await
8195 }
8196 pub async fn convert_to_text_with_options(
8197 &self,
8198 params: &DocListsConvertToTextBoundParams,
8199 options: InvokeOptions,
8200 ) -> Result<DocListsConvertToTextResult> {
8201 let params = serde_json::to_value(params)
8202 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8203 let result = self
8204 .invoker
8205 .invoke("doc.lists.convertToText", params, options)
8206 .await?;
8207 serde_json::from_value(result).map_err(|decode| {
8208 let mut error = Error::decode(decode);
8209 error.operation_id = Some("doc.lists.convertToText".to_owned());
8210 error.outcome_unknown = true;
8211 error
8212 })
8213 }
8214
8215 pub async fn create(&self, params: &DocListsCreateBoundParams) -> Result<DocListsCreateResult> {
8216 self.create_with_options(params, InvokeOptions::default())
8217 .await
8218 }
8219 pub async fn create_with_options(
8220 &self,
8221 params: &DocListsCreateBoundParams,
8222 options: InvokeOptions,
8223 ) -> Result<DocListsCreateResult> {
8224 let params = serde_json::to_value(params)
8225 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8226 let result = self
8227 .invoker
8228 .invoke("doc.lists.create", params, options)
8229 .await?;
8230 serde_json::from_value(result).map_err(|decode| {
8231 let mut error = Error::decode(decode);
8232 error.operation_id = Some("doc.lists.create".to_owned());
8233 error.outcome_unknown = true;
8234 error
8235 })
8236 }
8237
8238 pub async fn delete(&self, params: &DocListsDeleteBoundParams) -> Result<DocListsDeleteResult> {
8239 self.delete_with_options(params, InvokeOptions::default())
8240 .await
8241 }
8242 pub async fn delete_with_options(
8243 &self,
8244 params: &DocListsDeleteBoundParams,
8245 options: InvokeOptions,
8246 ) -> Result<DocListsDeleteResult> {
8247 let params = serde_json::to_value(params)
8248 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8249 let result = self
8250 .invoker
8251 .invoke("doc.lists.delete", params, options)
8252 .await?;
8253 serde_json::from_value(result).map_err(|decode| {
8254 let mut error = Error::decode(decode);
8255 error.operation_id = Some("doc.lists.delete".to_owned());
8256 error.outcome_unknown = true;
8257 error
8258 })
8259 }
8260
8261 pub async fn detach(&self, params: &DocListsDetachBoundParams) -> Result<DocListsDetachResult> {
8262 self.detach_with_options(params, InvokeOptions::default())
8263 .await
8264 }
8265 pub async fn detach_with_options(
8266 &self,
8267 params: &DocListsDetachBoundParams,
8268 options: InvokeOptions,
8269 ) -> Result<DocListsDetachResult> {
8270 let params = serde_json::to_value(params)
8271 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8272 let result = self
8273 .invoker
8274 .invoke("doc.lists.detach", params, options)
8275 .await?;
8276 serde_json::from_value(result).map_err(|decode| {
8277 let mut error = Error::decode(decode);
8278 error.operation_id = Some("doc.lists.detach".to_owned());
8279 error.outcome_unknown = true;
8280 error
8281 })
8282 }
8283
8284 pub async fn get(&self, params: &DocListsGetBoundParams) -> Result<DocListsGetResult> {
8285 self.get_with_options(params, InvokeOptions::default())
8286 .await
8287 }
8288 pub async fn get_with_options(
8289 &self,
8290 params: &DocListsGetBoundParams,
8291 options: InvokeOptions,
8292 ) -> Result<DocListsGetResult> {
8293 let params = serde_json::to_value(params)
8294 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8295 let result = self
8296 .invoker
8297 .invoke("doc.lists.get", params, options)
8298 .await?;
8299 serde_json::from_value(result).map_err(|decode| {
8300 let mut error = Error::decode(decode);
8301 error.operation_id = Some("doc.lists.get".to_owned());
8302 error.outcome_unknown = false;
8303 error
8304 })
8305 }
8306
8307 pub async fn get_state(
8308 &self,
8309 params: &DocListsGetStateBoundParams,
8310 ) -> Result<DocListsGetStateResult> {
8311 self.get_state_with_options(params, InvokeOptions::default())
8312 .await
8313 }
8314 pub async fn get_state_with_options(
8315 &self,
8316 params: &DocListsGetStateBoundParams,
8317 options: InvokeOptions,
8318 ) -> Result<DocListsGetStateResult> {
8319 let params = serde_json::to_value(params)
8320 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8321 let result = self
8322 .invoker
8323 .invoke("doc.lists.getState", params, options)
8324 .await?;
8325 serde_json::from_value(result).map_err(|decode| {
8326 let mut error = Error::decode(decode);
8327 error.operation_id = Some("doc.lists.getState".to_owned());
8328 error.outcome_unknown = false;
8329 error
8330 })
8331 }
8332
8333 pub async fn get_style(
8334 &self,
8335 params: &DocListsGetStyleBoundParams,
8336 ) -> Result<DocListsGetStyleResult> {
8337 self.get_style_with_options(params, InvokeOptions::default())
8338 .await
8339 }
8340 pub async fn get_style_with_options(
8341 &self,
8342 params: &DocListsGetStyleBoundParams,
8343 options: InvokeOptions,
8344 ) -> Result<DocListsGetStyleResult> {
8345 let params = serde_json::to_value(params)
8346 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8347 let result = self
8348 .invoker
8349 .invoke("doc.lists.getStyle", params, options)
8350 .await?;
8351 serde_json::from_value(result).map_err(|decode| {
8352 let mut error = Error::decode(decode);
8353 error.operation_id = Some("doc.lists.getStyle".to_owned());
8354 error.outcome_unknown = false;
8355 error
8356 })
8357 }
8358
8359 pub async fn indent(&self, params: &DocListsIndentBoundParams) -> Result<DocListsIndentResult> {
8360 self.indent_with_options(params, InvokeOptions::default())
8361 .await
8362 }
8363 pub async fn indent_with_options(
8364 &self,
8365 params: &DocListsIndentBoundParams,
8366 options: InvokeOptions,
8367 ) -> Result<DocListsIndentResult> {
8368 let params = serde_json::to_value(params)
8369 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8370 let result = self
8371 .invoker
8372 .invoke("doc.lists.indent", params, options)
8373 .await?;
8374 serde_json::from_value(result).map_err(|decode| {
8375 let mut error = Error::decode(decode);
8376 error.operation_id = Some("doc.lists.indent".to_owned());
8377 error.outcome_unknown = true;
8378 error
8379 })
8380 }
8381
8382 pub async fn insert(&self, params: &DocListsInsertBoundParams) -> Result<DocListsInsertResult> {
8383 self.insert_with_options(params, InvokeOptions::default())
8384 .await
8385 }
8386 pub async fn insert_with_options(
8387 &self,
8388 params: &DocListsInsertBoundParams,
8389 options: InvokeOptions,
8390 ) -> Result<DocListsInsertResult> {
8391 let params = serde_json::to_value(params)
8392 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8393 let result = self
8394 .invoker
8395 .invoke("doc.lists.insert", params, options)
8396 .await?;
8397 serde_json::from_value(result).map_err(|decode| {
8398 let mut error = Error::decode(decode);
8399 error.operation_id = Some("doc.lists.insert".to_owned());
8400 error.outcome_unknown = true;
8401 error
8402 })
8403 }
8404
8405 pub async fn join(&self, params: &DocListsJoinBoundParams) -> Result<DocListsJoinResult> {
8406 self.join_with_options(params, InvokeOptions::default())
8407 .await
8408 }
8409 pub async fn join_with_options(
8410 &self,
8411 params: &DocListsJoinBoundParams,
8412 options: InvokeOptions,
8413 ) -> Result<DocListsJoinResult> {
8414 let params = serde_json::to_value(params)
8415 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8416 let result = self
8417 .invoker
8418 .invoke("doc.lists.join", params, options)
8419 .await?;
8420 serde_json::from_value(result).map_err(|decode| {
8421 let mut error = Error::decode(decode);
8422 error.operation_id = Some("doc.lists.join".to_owned());
8423 error.outcome_unknown = true;
8424 error
8425 })
8426 }
8427
8428 pub async fn list(&self, params: &DocListsListBoundParams) -> Result<DocListsListResult> {
8429 self.list_with_options(params, InvokeOptions::default())
8430 .await
8431 }
8432 pub async fn list_with_options(
8433 &self,
8434 params: &DocListsListBoundParams,
8435 options: InvokeOptions,
8436 ) -> Result<DocListsListResult> {
8437 let params = serde_json::to_value(params)
8438 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8439 let result = self
8440 .invoker
8441 .invoke("doc.lists.list", params, options)
8442 .await?;
8443 serde_json::from_value(result).map_err(|decode| {
8444 let mut error = Error::decode(decode);
8445 error.operation_id = Some("doc.lists.list".to_owned());
8446 error.outcome_unknown = false;
8447 error
8448 })
8449 }
8450
8451 pub async fn merge(&self, params: &DocListsMergeBoundParams) -> Result<DocListsMergeResult> {
8452 self.merge_with_options(params, InvokeOptions::default())
8453 .await
8454 }
8455 pub async fn merge_with_options(
8456 &self,
8457 params: &DocListsMergeBoundParams,
8458 options: InvokeOptions,
8459 ) -> Result<DocListsMergeResult> {
8460 let params = serde_json::to_value(params)
8461 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8462 let result = self
8463 .invoker
8464 .invoke("doc.lists.merge", params, options)
8465 .await?;
8466 serde_json::from_value(result).map_err(|decode| {
8467 let mut error = Error::decode(decode);
8468 error.operation_id = Some("doc.lists.merge".to_owned());
8469 error.outcome_unknown = true;
8470 error
8471 })
8472 }
8473
8474 pub async fn outdent(
8475 &self,
8476 params: &DocListsOutdentBoundParams,
8477 ) -> Result<DocListsOutdentResult> {
8478 self.outdent_with_options(params, InvokeOptions::default())
8479 .await
8480 }
8481 pub async fn outdent_with_options(
8482 &self,
8483 params: &DocListsOutdentBoundParams,
8484 options: InvokeOptions,
8485 ) -> Result<DocListsOutdentResult> {
8486 let params = serde_json::to_value(params)
8487 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8488 let result = self
8489 .invoker
8490 .invoke("doc.lists.outdent", params, options)
8491 .await?;
8492 serde_json::from_value(result).map_err(|decode| {
8493 let mut error = Error::decode(decode);
8494 error.operation_id = Some("doc.lists.outdent".to_owned());
8495 error.outcome_unknown = true;
8496 error
8497 })
8498 }
8499
8500 pub async fn remove(&self, params: &DocListsRemoveBoundParams) -> Result<DocListsRemoveResult> {
8501 self.remove_with_options(params, InvokeOptions::default())
8502 .await
8503 }
8504 pub async fn remove_with_options(
8505 &self,
8506 params: &DocListsRemoveBoundParams,
8507 options: InvokeOptions,
8508 ) -> Result<DocListsRemoveResult> {
8509 let params = serde_json::to_value(params)
8510 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8511 let result = self
8512 .invoker
8513 .invoke("doc.lists.remove", params, options)
8514 .await?;
8515 serde_json::from_value(result).map_err(|decode| {
8516 let mut error = Error::decode(decode);
8517 error.operation_id = Some("doc.lists.remove".to_owned());
8518 error.outcome_unknown = true;
8519 error
8520 })
8521 }
8522
8523 pub async fn restart(
8524 &self,
8525 params: &DocListsRestartBoundParams,
8526 ) -> Result<DocListsRestartResult> {
8527 self.restart_with_options(params, InvokeOptions::default())
8528 .await
8529 }
8530 pub async fn restart_with_options(
8531 &self,
8532 params: &DocListsRestartBoundParams,
8533 options: InvokeOptions,
8534 ) -> Result<DocListsRestartResult> {
8535 let params = serde_json::to_value(params)
8536 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8537 let result = self
8538 .invoker
8539 .invoke("doc.lists.restart", params, options)
8540 .await?;
8541 serde_json::from_value(result).map_err(|decode| {
8542 let mut error = Error::decode(decode);
8543 error.operation_id = Some("doc.lists.restart".to_owned());
8544 error.outcome_unknown = true;
8545 error
8546 })
8547 }
8548
8549 pub async fn restart_at(
8550 &self,
8551 params: &DocListsRestartAtBoundParams,
8552 ) -> Result<DocListsRestartAtResult> {
8553 self.restart_at_with_options(params, InvokeOptions::default())
8554 .await
8555 }
8556 pub async fn restart_at_with_options(
8557 &self,
8558 params: &DocListsRestartAtBoundParams,
8559 options: InvokeOptions,
8560 ) -> Result<DocListsRestartAtResult> {
8561 let params = serde_json::to_value(params)
8562 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8563 let result = self
8564 .invoker
8565 .invoke("doc.lists.restartAt", params, options)
8566 .await?;
8567 serde_json::from_value(result).map_err(|decode| {
8568 let mut error = Error::decode(decode);
8569 error.operation_id = Some("doc.lists.restartAt".to_owned());
8570 error.outcome_unknown = true;
8571 error
8572 })
8573 }
8574
8575 pub async fn separate(
8576 &self,
8577 params: &DocListsSeparateBoundParams,
8578 ) -> Result<DocListsSeparateResult> {
8579 self.separate_with_options(params, InvokeOptions::default())
8580 .await
8581 }
8582 pub async fn separate_with_options(
8583 &self,
8584 params: &DocListsSeparateBoundParams,
8585 options: InvokeOptions,
8586 ) -> Result<DocListsSeparateResult> {
8587 let params = serde_json::to_value(params)
8588 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8589 let result = self
8590 .invoker
8591 .invoke("doc.lists.separate", params, options)
8592 .await?;
8593 serde_json::from_value(result).map_err(|decode| {
8594 let mut error = Error::decode(decode);
8595 error.operation_id = Some("doc.lists.separate".to_owned());
8596 error.outcome_unknown = true;
8597 error
8598 })
8599 }
8600
8601 pub async fn set_level(
8602 &self,
8603 params: &DocListsSetLevelBoundParams,
8604 ) -> Result<DocListsSetLevelResult> {
8605 self.set_level_with_options(params, InvokeOptions::default())
8606 .await
8607 }
8608 pub async fn set_level_with_options(
8609 &self,
8610 params: &DocListsSetLevelBoundParams,
8611 options: InvokeOptions,
8612 ) -> Result<DocListsSetLevelResult> {
8613 let params = serde_json::to_value(params)
8614 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8615 let result = self
8616 .invoker
8617 .invoke("doc.lists.setLevel", params, options)
8618 .await?;
8619 serde_json::from_value(result).map_err(|decode| {
8620 let mut error = Error::decode(decode);
8621 error.operation_id = Some("doc.lists.setLevel".to_owned());
8622 error.outcome_unknown = true;
8623 error
8624 })
8625 }
8626
8627 pub async fn set_level_alignment(
8628 &self,
8629 params: &DocListsSetLevelAlignmentBoundParams,
8630 ) -> Result<DocListsSetLevelAlignmentResult> {
8631 self.set_level_alignment_with_options(params, InvokeOptions::default())
8632 .await
8633 }
8634 pub async fn set_level_alignment_with_options(
8635 &self,
8636 params: &DocListsSetLevelAlignmentBoundParams,
8637 options: InvokeOptions,
8638 ) -> Result<DocListsSetLevelAlignmentResult> {
8639 let params = serde_json::to_value(params)
8640 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8641 let result = self
8642 .invoker
8643 .invoke("doc.lists.setLevelAlignment", params, options)
8644 .await?;
8645 serde_json::from_value(result).map_err(|decode| {
8646 let mut error = Error::decode(decode);
8647 error.operation_id = Some("doc.lists.setLevelAlignment".to_owned());
8648 error.outcome_unknown = true;
8649 error
8650 })
8651 }
8652
8653 pub async fn set_level_bullet(
8654 &self,
8655 params: &DocListsSetLevelBulletBoundParams,
8656 ) -> Result<DocListsSetLevelBulletResult> {
8657 self.set_level_bullet_with_options(params, InvokeOptions::default())
8658 .await
8659 }
8660 pub async fn set_level_bullet_with_options(
8661 &self,
8662 params: &DocListsSetLevelBulletBoundParams,
8663 options: InvokeOptions,
8664 ) -> Result<DocListsSetLevelBulletResult> {
8665 let params = serde_json::to_value(params)
8666 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8667 let result = self
8668 .invoker
8669 .invoke("doc.lists.setLevelBullet", params, options)
8670 .await?;
8671 serde_json::from_value(result).map_err(|decode| {
8672 let mut error = Error::decode(decode);
8673 error.operation_id = Some("doc.lists.setLevelBullet".to_owned());
8674 error.outcome_unknown = true;
8675 error
8676 })
8677 }
8678
8679 pub async fn set_level_indents(
8680 &self,
8681 params: &DocListsSetLevelIndentsBoundParams,
8682 ) -> Result<DocListsSetLevelIndentsResult> {
8683 self.set_level_indents_with_options(params, InvokeOptions::default())
8684 .await
8685 }
8686 pub async fn set_level_indents_with_options(
8687 &self,
8688 params: &DocListsSetLevelIndentsBoundParams,
8689 options: InvokeOptions,
8690 ) -> Result<DocListsSetLevelIndentsResult> {
8691 let params = serde_json::to_value(params)
8692 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8693 let result = self
8694 .invoker
8695 .invoke("doc.lists.setLevelIndents", params, options)
8696 .await?;
8697 serde_json::from_value(result).map_err(|decode| {
8698 let mut error = Error::decode(decode);
8699 error.operation_id = Some("doc.lists.setLevelIndents".to_owned());
8700 error.outcome_unknown = true;
8701 error
8702 })
8703 }
8704
8705 pub async fn set_level_layout(
8706 &self,
8707 params: &DocListsSetLevelLayoutBoundParams,
8708 ) -> Result<DocListsSetLevelLayoutResult> {
8709 self.set_level_layout_with_options(params, InvokeOptions::default())
8710 .await
8711 }
8712 pub async fn set_level_layout_with_options(
8713 &self,
8714 params: &DocListsSetLevelLayoutBoundParams,
8715 options: InvokeOptions,
8716 ) -> Result<DocListsSetLevelLayoutResult> {
8717 let params = serde_json::to_value(params)
8718 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8719 let result = self
8720 .invoker
8721 .invoke("doc.lists.setLevelLayout", params, options)
8722 .await?;
8723 serde_json::from_value(result).map_err(|decode| {
8724 let mut error = Error::decode(decode);
8725 error.operation_id = Some("doc.lists.setLevelLayout".to_owned());
8726 error.outcome_unknown = true;
8727 error
8728 })
8729 }
8730
8731 pub async fn set_level_marker_font(
8732 &self,
8733 params: &DocListsSetLevelMarkerFontBoundParams,
8734 ) -> Result<DocListsSetLevelMarkerFontResult> {
8735 self.set_level_marker_font_with_options(params, InvokeOptions::default())
8736 .await
8737 }
8738 pub async fn set_level_marker_font_with_options(
8739 &self,
8740 params: &DocListsSetLevelMarkerFontBoundParams,
8741 options: InvokeOptions,
8742 ) -> Result<DocListsSetLevelMarkerFontResult> {
8743 let params = serde_json::to_value(params)
8744 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8745 let result = self
8746 .invoker
8747 .invoke("doc.lists.setLevelMarkerFont", params, options)
8748 .await?;
8749 serde_json::from_value(result).map_err(|decode| {
8750 let mut error = Error::decode(decode);
8751 error.operation_id = Some("doc.lists.setLevelMarkerFont".to_owned());
8752 error.outcome_unknown = true;
8753 error
8754 })
8755 }
8756
8757 pub async fn set_level_numbering(
8758 &self,
8759 params: &DocListsSetLevelNumberingBoundParams,
8760 ) -> Result<DocListsSetLevelNumberingResult> {
8761 self.set_level_numbering_with_options(params, InvokeOptions::default())
8762 .await
8763 }
8764 pub async fn set_level_numbering_with_options(
8765 &self,
8766 params: &DocListsSetLevelNumberingBoundParams,
8767 options: InvokeOptions,
8768 ) -> Result<DocListsSetLevelNumberingResult> {
8769 let params = serde_json::to_value(params)
8770 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8771 let result = self
8772 .invoker
8773 .invoke("doc.lists.setLevelNumbering", params, options)
8774 .await?;
8775 serde_json::from_value(result).map_err(|decode| {
8776 let mut error = Error::decode(decode);
8777 error.operation_id = Some("doc.lists.setLevelNumbering".to_owned());
8778 error.outcome_unknown = true;
8779 error
8780 })
8781 }
8782
8783 pub async fn set_level_number_style(
8784 &self,
8785 params: &DocListsSetLevelNumberStyleBoundParams,
8786 ) -> Result<DocListsSetLevelNumberStyleResult> {
8787 self.set_level_number_style_with_options(params, InvokeOptions::default())
8788 .await
8789 }
8790 pub async fn set_level_number_style_with_options(
8791 &self,
8792 params: &DocListsSetLevelNumberStyleBoundParams,
8793 options: InvokeOptions,
8794 ) -> Result<DocListsSetLevelNumberStyleResult> {
8795 let params = serde_json::to_value(params)
8796 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8797 let result = self
8798 .invoker
8799 .invoke("doc.lists.setLevelNumberStyle", params, options)
8800 .await?;
8801 serde_json::from_value(result).map_err(|decode| {
8802 let mut error = Error::decode(decode);
8803 error.operation_id = Some("doc.lists.setLevelNumberStyle".to_owned());
8804 error.outcome_unknown = true;
8805 error
8806 })
8807 }
8808
8809 pub async fn set_level_picture_bullet(
8810 &self,
8811 params: &DocListsSetLevelPictureBulletBoundParams,
8812 ) -> Result<DocListsSetLevelPictureBulletResult> {
8813 self.set_level_picture_bullet_with_options(params, InvokeOptions::default())
8814 .await
8815 }
8816 pub async fn set_level_picture_bullet_with_options(
8817 &self,
8818 params: &DocListsSetLevelPictureBulletBoundParams,
8819 options: InvokeOptions,
8820 ) -> Result<DocListsSetLevelPictureBulletResult> {
8821 let params = serde_json::to_value(params)
8822 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8823 let result = self
8824 .invoker
8825 .invoke("doc.lists.setLevelPictureBullet", params, options)
8826 .await?;
8827 serde_json::from_value(result).map_err(|decode| {
8828 let mut error = Error::decode(decode);
8829 error.operation_id = Some("doc.lists.setLevelPictureBullet".to_owned());
8830 error.outcome_unknown = true;
8831 error
8832 })
8833 }
8834
8835 pub async fn set_level_restart(
8836 &self,
8837 params: &DocListsSetLevelRestartBoundParams,
8838 ) -> Result<DocListsSetLevelRestartResult> {
8839 self.set_level_restart_with_options(params, InvokeOptions::default())
8840 .await
8841 }
8842 pub async fn set_level_restart_with_options(
8843 &self,
8844 params: &DocListsSetLevelRestartBoundParams,
8845 options: InvokeOptions,
8846 ) -> Result<DocListsSetLevelRestartResult> {
8847 let params = serde_json::to_value(params)
8848 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8849 let result = self
8850 .invoker
8851 .invoke("doc.lists.setLevelRestart", params, options)
8852 .await?;
8853 serde_json::from_value(result).map_err(|decode| {
8854 let mut error = Error::decode(decode);
8855 error.operation_id = Some("doc.lists.setLevelRestart".to_owned());
8856 error.outcome_unknown = true;
8857 error
8858 })
8859 }
8860
8861 pub async fn set_level_start(
8862 &self,
8863 params: &DocListsSetLevelStartBoundParams,
8864 ) -> Result<DocListsSetLevelStartResult> {
8865 self.set_level_start_with_options(params, InvokeOptions::default())
8866 .await
8867 }
8868 pub async fn set_level_start_with_options(
8869 &self,
8870 params: &DocListsSetLevelStartBoundParams,
8871 options: InvokeOptions,
8872 ) -> Result<DocListsSetLevelStartResult> {
8873 let params = serde_json::to_value(params)
8874 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8875 let result = self
8876 .invoker
8877 .invoke("doc.lists.setLevelStart", params, options)
8878 .await?;
8879 serde_json::from_value(result).map_err(|decode| {
8880 let mut error = Error::decode(decode);
8881 error.operation_id = Some("doc.lists.setLevelStart".to_owned());
8882 error.outcome_unknown = true;
8883 error
8884 })
8885 }
8886
8887 pub async fn set_level_text(
8888 &self,
8889 params: &DocListsSetLevelTextBoundParams,
8890 ) -> Result<DocListsSetLevelTextResult> {
8891 self.set_level_text_with_options(params, InvokeOptions::default())
8892 .await
8893 }
8894 pub async fn set_level_text_with_options(
8895 &self,
8896 params: &DocListsSetLevelTextBoundParams,
8897 options: InvokeOptions,
8898 ) -> Result<DocListsSetLevelTextResult> {
8899 let params = serde_json::to_value(params)
8900 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8901 let result = self
8902 .invoker
8903 .invoke("doc.lists.setLevelText", params, options)
8904 .await?;
8905 serde_json::from_value(result).map_err(|decode| {
8906 let mut error = Error::decode(decode);
8907 error.operation_id = Some("doc.lists.setLevelText".to_owned());
8908 error.outcome_unknown = true;
8909 error
8910 })
8911 }
8912
8913 pub async fn set_level_trailing_character(
8914 &self,
8915 params: &DocListsSetLevelTrailingCharacterBoundParams,
8916 ) -> Result<DocListsSetLevelTrailingCharacterResult> {
8917 self.set_level_trailing_character_with_options(params, InvokeOptions::default())
8918 .await
8919 }
8920 pub async fn set_level_trailing_character_with_options(
8921 &self,
8922 params: &DocListsSetLevelTrailingCharacterBoundParams,
8923 options: InvokeOptions,
8924 ) -> Result<DocListsSetLevelTrailingCharacterResult> {
8925 let params = serde_json::to_value(params)
8926 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8927 let result = self
8928 .invoker
8929 .invoke("doc.lists.setLevelTrailingCharacter", params, options)
8930 .await?;
8931 serde_json::from_value(result).map_err(|decode| {
8932 let mut error = Error::decode(decode);
8933 error.operation_id = Some("doc.lists.setLevelTrailingCharacter".to_owned());
8934 error.outcome_unknown = true;
8935 error
8936 })
8937 }
8938
8939 pub async fn set_type(
8940 &self,
8941 params: &DocListsSetTypeBoundParams,
8942 ) -> Result<DocListsSetTypeResult> {
8943 self.set_type_with_options(params, InvokeOptions::default())
8944 .await
8945 }
8946 pub async fn set_type_with_options(
8947 &self,
8948 params: &DocListsSetTypeBoundParams,
8949 options: InvokeOptions,
8950 ) -> Result<DocListsSetTypeResult> {
8951 let params = serde_json::to_value(params)
8952 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8953 let result = self
8954 .invoker
8955 .invoke("doc.lists.setType", params, options)
8956 .await?;
8957 serde_json::from_value(result).map_err(|decode| {
8958 let mut error = Error::decode(decode);
8959 error.operation_id = Some("doc.lists.setType".to_owned());
8960 error.outcome_unknown = true;
8961 error
8962 })
8963 }
8964
8965 pub async fn set_value(
8966 &self,
8967 params: &DocListsSetValueBoundParams,
8968 ) -> Result<DocListsSetValueResult> {
8969 self.set_value_with_options(params, InvokeOptions::default())
8970 .await
8971 }
8972 pub async fn set_value_with_options(
8973 &self,
8974 params: &DocListsSetValueBoundParams,
8975 options: InvokeOptions,
8976 ) -> Result<DocListsSetValueResult> {
8977 let params = serde_json::to_value(params)
8978 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
8979 let result = self
8980 .invoker
8981 .invoke("doc.lists.setValue", params, options)
8982 .await?;
8983 serde_json::from_value(result).map_err(|decode| {
8984 let mut error = Error::decode(decode);
8985 error.operation_id = Some("doc.lists.setValue".to_owned());
8986 error.outcome_unknown = true;
8987 error
8988 })
8989 }
8990
8991 pub async fn split(&self, params: &DocListsSplitBoundParams) -> Result<DocListsSplitResult> {
8992 self.split_with_options(params, InvokeOptions::default())
8993 .await
8994 }
8995 pub async fn split_with_options(
8996 &self,
8997 params: &DocListsSplitBoundParams,
8998 options: InvokeOptions,
8999 ) -> Result<DocListsSplitResult> {
9000 let params = serde_json::to_value(params)
9001 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9002 let result = self
9003 .invoker
9004 .invoke("doc.lists.split", params, options)
9005 .await?;
9006 serde_json::from_value(result).map_err(|decode| {
9007 let mut error = Error::decode(decode);
9008 error.operation_id = Some("doc.lists.split".to_owned());
9009 error.outcome_unknown = true;
9010 error
9011 })
9012 }
9013}
9014
9015pub struct DocApiMetadata<'a, I: Invoker> {
9016 invoker: &'a I,
9017}
9018impl<'a, I: Invoker> DocApiMetadata<'a, I> {
9019 pub fn new(invoker: &'a I) -> Self {
9020 Self { invoker }
9021 }
9022
9023 pub async fn attach(
9024 &self,
9025 params: &DocMetadataAttachBoundParams,
9026 ) -> Result<DocMetadataAttachResult> {
9027 self.attach_with_options(params, InvokeOptions::default())
9028 .await
9029 }
9030 pub async fn attach_with_options(
9031 &self,
9032 params: &DocMetadataAttachBoundParams,
9033 options: InvokeOptions,
9034 ) -> Result<DocMetadataAttachResult> {
9035 let params = serde_json::to_value(params)
9036 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9037 let result = self
9038 .invoker
9039 .invoke("doc.metadata.attach", params, options)
9040 .await?;
9041 serde_json::from_value(result).map_err(|decode| {
9042 let mut error = Error::decode(decode);
9043 error.operation_id = Some("doc.metadata.attach".to_owned());
9044 error.outcome_unknown = true;
9045 error
9046 })
9047 }
9048
9049 pub async fn get(&self, params: &DocMetadataGetBoundParams) -> Result<DocMetadataGetResult> {
9050 self.get_with_options(params, InvokeOptions::default())
9051 .await
9052 }
9053 pub async fn get_with_options(
9054 &self,
9055 params: &DocMetadataGetBoundParams,
9056 options: InvokeOptions,
9057 ) -> Result<DocMetadataGetResult> {
9058 let params = serde_json::to_value(params)
9059 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9060 let result = self
9061 .invoker
9062 .invoke("doc.metadata.get", params, options)
9063 .await?;
9064 serde_json::from_value(result).map_err(|decode| {
9065 let mut error = Error::decode(decode);
9066 error.operation_id = Some("doc.metadata.get".to_owned());
9067 error.outcome_unknown = false;
9068 error
9069 })
9070 }
9071
9072 pub async fn list(&self, params: &DocMetadataListBoundParams) -> Result<DocMetadataListResult> {
9073 self.list_with_options(params, InvokeOptions::default())
9074 .await
9075 }
9076 pub async fn list_with_options(
9077 &self,
9078 params: &DocMetadataListBoundParams,
9079 options: InvokeOptions,
9080 ) -> Result<DocMetadataListResult> {
9081 let params = serde_json::to_value(params)
9082 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9083 let result = self
9084 .invoker
9085 .invoke("doc.metadata.list", params, options)
9086 .await?;
9087 serde_json::from_value(result).map_err(|decode| {
9088 let mut error = Error::decode(decode);
9089 error.operation_id = Some("doc.metadata.list".to_owned());
9090 error.outcome_unknown = false;
9091 error
9092 })
9093 }
9094
9095 pub async fn remove(
9096 &self,
9097 params: &DocMetadataRemoveBoundParams,
9098 ) -> Result<DocMetadataRemoveResult> {
9099 self.remove_with_options(params, InvokeOptions::default())
9100 .await
9101 }
9102 pub async fn remove_with_options(
9103 &self,
9104 params: &DocMetadataRemoveBoundParams,
9105 options: InvokeOptions,
9106 ) -> Result<DocMetadataRemoveResult> {
9107 let params = serde_json::to_value(params)
9108 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9109 let result = self
9110 .invoker
9111 .invoke("doc.metadata.remove", params, options)
9112 .await?;
9113 serde_json::from_value(result).map_err(|decode| {
9114 let mut error = Error::decode(decode);
9115 error.operation_id = Some("doc.metadata.remove".to_owned());
9116 error.outcome_unknown = true;
9117 error
9118 })
9119 }
9120
9121 pub async fn resolve(
9122 &self,
9123 params: &DocMetadataResolveBoundParams,
9124 ) -> Result<DocMetadataResolveResult> {
9125 self.resolve_with_options(params, InvokeOptions::default())
9126 .await
9127 }
9128 pub async fn resolve_with_options(
9129 &self,
9130 params: &DocMetadataResolveBoundParams,
9131 options: InvokeOptions,
9132 ) -> Result<DocMetadataResolveResult> {
9133 let params = serde_json::to_value(params)
9134 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9135 let result = self
9136 .invoker
9137 .invoke("doc.metadata.resolve", params, options)
9138 .await?;
9139 serde_json::from_value(result).map_err(|decode| {
9140 let mut error = Error::decode(decode);
9141 error.operation_id = Some("doc.metadata.resolve".to_owned());
9142 error.outcome_unknown = false;
9143 error
9144 })
9145 }
9146
9147 pub async fn update(
9148 &self,
9149 params: &DocMetadataUpdateBoundParams,
9150 ) -> Result<DocMetadataUpdateResult> {
9151 self.update_with_options(params, InvokeOptions::default())
9152 .await
9153 }
9154 pub async fn update_with_options(
9155 &self,
9156 params: &DocMetadataUpdateBoundParams,
9157 options: InvokeOptions,
9158 ) -> Result<DocMetadataUpdateResult> {
9159 let params = serde_json::to_value(params)
9160 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9161 let result = self
9162 .invoker
9163 .invoke("doc.metadata.update", params, options)
9164 .await?;
9165 serde_json::from_value(result).map_err(|decode| {
9166 let mut error = Error::decode(decode);
9167 error.operation_id = Some("doc.metadata.update".to_owned());
9168 error.outcome_unknown = true;
9169 error
9170 })
9171 }
9172}
9173
9174pub struct DocApiMutations<'a, I: Invoker> {
9175 invoker: &'a I,
9176}
9177impl<'a, I: Invoker> DocApiMutations<'a, I> {
9178 pub fn new(invoker: &'a I) -> Self {
9179 Self { invoker }
9180 }
9181
9182 pub async fn apply(
9183 &self,
9184 params: &DocMutationsApplyBoundParams,
9185 ) -> Result<DocMutationsApplyResult> {
9186 self.apply_with_options(params, InvokeOptions::default())
9187 .await
9188 }
9189 pub async fn apply_with_options(
9190 &self,
9191 params: &DocMutationsApplyBoundParams,
9192 options: InvokeOptions,
9193 ) -> Result<DocMutationsApplyResult> {
9194 let params = serde_json::to_value(params)
9195 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9196 let result = self
9197 .invoker
9198 .invoke("doc.mutations.apply", params, options)
9199 .await?;
9200 serde_json::from_value(result).map_err(|decode| {
9201 let mut error = Error::decode(decode);
9202 error.operation_id = Some("doc.mutations.apply".to_owned());
9203 error.outcome_unknown = true;
9204 error
9205 })
9206 }
9207
9208 pub async fn begin_temporary(
9209 &self,
9210 params: &DocMutationsBeginTemporaryBoundParams,
9211 ) -> Result<DocMutationsBeginTemporaryResult> {
9212 self.begin_temporary_with_options(params, InvokeOptions::default())
9213 .await
9214 }
9215 pub async fn begin_temporary_with_options(
9216 &self,
9217 params: &DocMutationsBeginTemporaryBoundParams,
9218 options: InvokeOptions,
9219 ) -> Result<DocMutationsBeginTemporaryResult> {
9220 let params = serde_json::to_value(params)
9221 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9222 let result = self
9223 .invoker
9224 .invoke("doc.mutations.beginTemporary", params, options)
9225 .await?;
9226 serde_json::from_value(result).map_err(|decode| {
9227 let mut error = Error::decode(decode);
9228 error.operation_id = Some("doc.mutations.beginTemporary".to_owned());
9229 error.outcome_unknown = true;
9230 error
9231 })
9232 }
9233
9234 pub async fn commit_temporary(
9235 &self,
9236 params: &DocMutationsCommitTemporaryBoundParams,
9237 ) -> Result<DocMutationsCommitTemporaryResult> {
9238 self.commit_temporary_with_options(params, InvokeOptions::default())
9239 .await
9240 }
9241 pub async fn commit_temporary_with_options(
9242 &self,
9243 params: &DocMutationsCommitTemporaryBoundParams,
9244 options: InvokeOptions,
9245 ) -> Result<DocMutationsCommitTemporaryResult> {
9246 let params = serde_json::to_value(params)
9247 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9248 let result = self
9249 .invoker
9250 .invoke("doc.mutations.commitTemporary", params, options)
9251 .await?;
9252 serde_json::from_value(result).map_err(|decode| {
9253 let mut error = Error::decode(decode);
9254 error.operation_id = Some("doc.mutations.commitTemporary".to_owned());
9255 error.outcome_unknown = true;
9256 error
9257 })
9258 }
9259
9260 pub async fn preview(
9261 &self,
9262 params: &DocMutationsPreviewBoundParams,
9263 ) -> Result<DocMutationsPreviewResult> {
9264 self.preview_with_options(params, InvokeOptions::default())
9265 .await
9266 }
9267 pub async fn preview_with_options(
9268 &self,
9269 params: &DocMutationsPreviewBoundParams,
9270 options: InvokeOptions,
9271 ) -> Result<DocMutationsPreviewResult> {
9272 let params = serde_json::to_value(params)
9273 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9274 let result = self
9275 .invoker
9276 .invoke("doc.mutations.preview", params, options)
9277 .await?;
9278 serde_json::from_value(result).map_err(|decode| {
9279 let mut error = Error::decode(decode);
9280 error.operation_id = Some("doc.mutations.preview".to_owned());
9281 error.outcome_unknown = false;
9282 error
9283 })
9284 }
9285
9286 pub async fn replace_temporary(
9287 &self,
9288 params: &DocMutationsReplaceTemporaryBoundParams,
9289 ) -> Result<DocMutationsReplaceTemporaryResult> {
9290 self.replace_temporary_with_options(params, InvokeOptions::default())
9291 .await
9292 }
9293 pub async fn replace_temporary_with_options(
9294 &self,
9295 params: &DocMutationsReplaceTemporaryBoundParams,
9296 options: InvokeOptions,
9297 ) -> Result<DocMutationsReplaceTemporaryResult> {
9298 let params = serde_json::to_value(params)
9299 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9300 let result = self
9301 .invoker
9302 .invoke("doc.mutations.replaceTemporary", params, options)
9303 .await?;
9304 serde_json::from_value(result).map_err(|decode| {
9305 let mut error = Error::decode(decode);
9306 error.operation_id = Some("doc.mutations.replaceTemporary".to_owned());
9307 error.outcome_unknown = true;
9308 error
9309 })
9310 }
9311
9312 pub async fn rollback_temporary(
9313 &self,
9314 params: &DocMutationsRollbackTemporaryBoundParams,
9315 ) -> Result<DocMutationsRollbackTemporaryResult> {
9316 self.rollback_temporary_with_options(params, InvokeOptions::default())
9317 .await
9318 }
9319 pub async fn rollback_temporary_with_options(
9320 &self,
9321 params: &DocMutationsRollbackTemporaryBoundParams,
9322 options: InvokeOptions,
9323 ) -> Result<DocMutationsRollbackTemporaryResult> {
9324 let params = serde_json::to_value(params)
9325 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9326 let result = self
9327 .invoker
9328 .invoke("doc.mutations.rollbackTemporary", params, options)
9329 .await?;
9330 serde_json::from_value(result).map_err(|decode| {
9331 let mut error = Error::decode(decode);
9332 error.operation_id = Some("doc.mutations.rollbackTemporary".to_owned());
9333 error.outcome_unknown = true;
9334 error
9335 })
9336 }
9337}
9338
9339pub struct DocApiPermissionRanges<'a, I: Invoker> {
9340 invoker: &'a I,
9341}
9342impl<'a, I: Invoker> DocApiPermissionRanges<'a, I> {
9343 pub fn new(invoker: &'a I) -> Self {
9344 Self { invoker }
9345 }
9346
9347 pub async fn create(
9348 &self,
9349 params: &DocPermissionRangesCreateBoundParams,
9350 ) -> Result<DocPermissionRangesCreateResult> {
9351 self.create_with_options(params, InvokeOptions::default())
9352 .await
9353 }
9354 pub async fn create_with_options(
9355 &self,
9356 params: &DocPermissionRangesCreateBoundParams,
9357 options: InvokeOptions,
9358 ) -> Result<DocPermissionRangesCreateResult> {
9359 let params = serde_json::to_value(params)
9360 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9361 let result = self
9362 .invoker
9363 .invoke("doc.permissionRanges.create", params, options)
9364 .await?;
9365 serde_json::from_value(result).map_err(|decode| {
9366 let mut error = Error::decode(decode);
9367 error.operation_id = Some("doc.permissionRanges.create".to_owned());
9368 error.outcome_unknown = true;
9369 error
9370 })
9371 }
9372
9373 pub async fn get(
9374 &self,
9375 params: &DocPermissionRangesGetBoundParams,
9376 ) -> Result<DocPermissionRangesGetResult> {
9377 self.get_with_options(params, InvokeOptions::default())
9378 .await
9379 }
9380 pub async fn get_with_options(
9381 &self,
9382 params: &DocPermissionRangesGetBoundParams,
9383 options: InvokeOptions,
9384 ) -> Result<DocPermissionRangesGetResult> {
9385 let params = serde_json::to_value(params)
9386 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9387 let result = self
9388 .invoker
9389 .invoke("doc.permissionRanges.get", params, options)
9390 .await?;
9391 serde_json::from_value(result).map_err(|decode| {
9392 let mut error = Error::decode(decode);
9393 error.operation_id = Some("doc.permissionRanges.get".to_owned());
9394 error.outcome_unknown = false;
9395 error
9396 })
9397 }
9398
9399 pub async fn list(
9400 &self,
9401 params: &DocPermissionRangesListBoundParams,
9402 ) -> Result<DocPermissionRangesListResult> {
9403 self.list_with_options(params, InvokeOptions::default())
9404 .await
9405 }
9406 pub async fn list_with_options(
9407 &self,
9408 params: &DocPermissionRangesListBoundParams,
9409 options: InvokeOptions,
9410 ) -> Result<DocPermissionRangesListResult> {
9411 let params = serde_json::to_value(params)
9412 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9413 let result = self
9414 .invoker
9415 .invoke("doc.permissionRanges.list", params, options)
9416 .await?;
9417 serde_json::from_value(result).map_err(|decode| {
9418 let mut error = Error::decode(decode);
9419 error.operation_id = Some("doc.permissionRanges.list".to_owned());
9420 error.outcome_unknown = false;
9421 error
9422 })
9423 }
9424
9425 pub async fn remove(
9426 &self,
9427 params: &DocPermissionRangesRemoveBoundParams,
9428 ) -> Result<DocPermissionRangesRemoveResult> {
9429 self.remove_with_options(params, InvokeOptions::default())
9430 .await
9431 }
9432 pub async fn remove_with_options(
9433 &self,
9434 params: &DocPermissionRangesRemoveBoundParams,
9435 options: InvokeOptions,
9436 ) -> Result<DocPermissionRangesRemoveResult> {
9437 let params = serde_json::to_value(params)
9438 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9439 let result = self
9440 .invoker
9441 .invoke("doc.permissionRanges.remove", params, options)
9442 .await?;
9443 serde_json::from_value(result).map_err(|decode| {
9444 let mut error = Error::decode(decode);
9445 error.operation_id = Some("doc.permissionRanges.remove".to_owned());
9446 error.outcome_unknown = true;
9447 error
9448 })
9449 }
9450
9451 pub async fn update_principal(
9452 &self,
9453 params: &DocPermissionRangesUpdatePrincipalBoundParams,
9454 ) -> Result<DocPermissionRangesUpdatePrincipalResult> {
9455 self.update_principal_with_options(params, InvokeOptions::default())
9456 .await
9457 }
9458 pub async fn update_principal_with_options(
9459 &self,
9460 params: &DocPermissionRangesUpdatePrincipalBoundParams,
9461 options: InvokeOptions,
9462 ) -> Result<DocPermissionRangesUpdatePrincipalResult> {
9463 let params = serde_json::to_value(params)
9464 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9465 let result = self
9466 .invoker
9467 .invoke("doc.permissionRanges.updatePrincipal", params, options)
9468 .await?;
9469 serde_json::from_value(result).map_err(|decode| {
9470 let mut error = Error::decode(decode);
9471 error.operation_id = Some("doc.permissionRanges.updatePrincipal".to_owned());
9472 error.outcome_unknown = true;
9473 error
9474 })
9475 }
9476}
9477
9478pub struct DocApiPlan<'a, I: Invoker> {
9479 invoker: &'a I,
9480}
9481impl<'a, I: Invoker> DocApiPlan<'a, I> {
9482 pub fn new(invoker: &'a I) -> Self {
9483 Self { invoker }
9484 }
9485
9486 pub async fn execute(
9487 &self,
9488 params: &DocPlanExecuteBoundParams,
9489 ) -> Result<DocPlanExecuteResult> {
9490 self.execute_with_options(params, InvokeOptions::default())
9491 .await
9492 }
9493 pub async fn execute_with_options(
9494 &self,
9495 params: &DocPlanExecuteBoundParams,
9496 options: InvokeOptions,
9497 ) -> Result<DocPlanExecuteResult> {
9498 let params = serde_json::to_value(params)
9499 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9500 let result = self
9501 .invoker
9502 .invoke("doc.plan.execute", params, options)
9503 .await?;
9504 serde_json::from_value(result).map_err(|decode| {
9505 let mut error = Error::decode(decode);
9506 error.operation_id = Some("doc.plan.execute".to_owned());
9507 error.outcome_unknown = true;
9508 error
9509 })
9510 }
9511}
9512
9513pub struct DocApiPreset<'a, I: Invoker> {
9514 invoker: &'a I,
9515}
9516impl<'a, I: Invoker> DocApiPreset<'a, I> {
9517 pub fn new(invoker: &'a I) -> Self {
9518 Self { invoker }
9519 }
9520
9521 pub async fn dispatch(
9522 &self,
9523 params: &DocPresetDispatchBoundParams,
9524 ) -> Result<DocPresetDispatchResult> {
9525 self.dispatch_with_options(params, InvokeOptions::default())
9526 .await
9527 }
9528 pub async fn dispatch_with_options(
9529 &self,
9530 params: &DocPresetDispatchBoundParams,
9531 options: InvokeOptions,
9532 ) -> Result<DocPresetDispatchResult> {
9533 let params = serde_json::to_value(params)
9534 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9535 let result = self
9536 .invoker
9537 .invoke("doc.preset.dispatch", params, options)
9538 .await?;
9539 serde_json::from_value(result).map_err(|decode| {
9540 let mut error = Error::decode(decode);
9541 error.operation_id = Some("doc.preset.dispatch".to_owned());
9542 error.outcome_unknown = true;
9543 error
9544 })
9545 }
9546
9547 pub async fn get_catalog(
9548 &self,
9549 params: &DocPresetGetCatalogBoundParams,
9550 ) -> Result<DocPresetGetCatalogResult> {
9551 self.get_catalog_with_options(params, InvokeOptions::default())
9552 .await
9553 }
9554 pub async fn get_catalog_with_options(
9555 &self,
9556 params: &DocPresetGetCatalogBoundParams,
9557 options: InvokeOptions,
9558 ) -> Result<DocPresetGetCatalogResult> {
9559 let params = serde_json::to_value(params)
9560 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9561 let result = self
9562 .invoker
9563 .invoke("doc.preset.getCatalog", params, options)
9564 .await?;
9565 serde_json::from_value(result).map_err(|decode| {
9566 let mut error = Error::decode(decode);
9567 error.operation_id = Some("doc.preset.getCatalog".to_owned());
9568 error.outcome_unknown = false;
9569 error
9570 })
9571 }
9572
9573 pub async fn get_mcp_prompt(
9574 &self,
9575 params: &DocPresetGetMcpPromptBoundParams,
9576 ) -> Result<DocPresetGetMcpPromptResult> {
9577 self.get_mcp_prompt_with_options(params, InvokeOptions::default())
9578 .await
9579 }
9580 pub async fn get_mcp_prompt_with_options(
9581 &self,
9582 params: &DocPresetGetMcpPromptBoundParams,
9583 options: InvokeOptions,
9584 ) -> Result<DocPresetGetMcpPromptResult> {
9585 let params = serde_json::to_value(params)
9586 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9587 let result = self
9588 .invoker
9589 .invoke("doc.preset.getMcpPrompt", params, options)
9590 .await?;
9591 serde_json::from_value(result).map_err(|decode| {
9592 let mut error = Error::decode(decode);
9593 error.operation_id = Some("doc.preset.getMcpPrompt".to_owned());
9594 error.outcome_unknown = false;
9595 error
9596 })
9597 }
9598
9599 pub async fn get_system_prompt(
9600 &self,
9601 params: &DocPresetGetSystemPromptBoundParams,
9602 ) -> Result<DocPresetGetSystemPromptResult> {
9603 self.get_system_prompt_with_options(params, InvokeOptions::default())
9604 .await
9605 }
9606 pub async fn get_system_prompt_with_options(
9607 &self,
9608 params: &DocPresetGetSystemPromptBoundParams,
9609 options: InvokeOptions,
9610 ) -> Result<DocPresetGetSystemPromptResult> {
9611 let params = serde_json::to_value(params)
9612 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9613 let result = self
9614 .invoker
9615 .invoke("doc.preset.getSystemPrompt", params, options)
9616 .await?;
9617 serde_json::from_value(result).map_err(|decode| {
9618 let mut error = Error::decode(decode);
9619 error.operation_id = Some("doc.preset.getSystemPrompt".to_owned());
9620 error.outcome_unknown = false;
9621 error
9622 })
9623 }
9624
9625 pub async fn get_tools(
9626 &self,
9627 params: &DocPresetGetToolsBoundParams,
9628 ) -> Result<DocPresetGetToolsResult> {
9629 self.get_tools_with_options(params, InvokeOptions::default())
9630 .await
9631 }
9632 pub async fn get_tools_with_options(
9633 &self,
9634 params: &DocPresetGetToolsBoundParams,
9635 options: InvokeOptions,
9636 ) -> Result<DocPresetGetToolsResult> {
9637 let params = serde_json::to_value(params)
9638 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9639 let result = self
9640 .invoker
9641 .invoke("doc.preset.getTools", params, options)
9642 .await?;
9643 serde_json::from_value(result).map_err(|decode| {
9644 let mut error = Error::decode(decode);
9645 error.operation_id = Some("doc.preset.getTools".to_owned());
9646 error.outcome_unknown = false;
9647 error
9648 })
9649 }
9650
9651 pub async fn list(&self, params: &DocPresetListBoundParams) -> Result<DocPresetListResult> {
9652 self.list_with_options(params, InvokeOptions::default())
9653 .await
9654 }
9655 pub async fn list_with_options(
9656 &self,
9657 params: &DocPresetListBoundParams,
9658 options: InvokeOptions,
9659 ) -> Result<DocPresetListResult> {
9660 let params = serde_json::to_value(params)
9661 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9662 let result = self
9663 .invoker
9664 .invoke("doc.preset.list", params, options)
9665 .await?;
9666 serde_json::from_value(result).map_err(|decode| {
9667 let mut error = Error::decode(decode);
9668 error.operation_id = Some("doc.preset.list".to_owned());
9669 error.outcome_unknown = false;
9670 error
9671 })
9672 }
9673}
9674
9675pub struct DocApiProtection<'a, I: Invoker> {
9676 invoker: &'a I,
9677}
9678impl<'a, I: Invoker> DocApiProtection<'a, I> {
9679 pub fn new(invoker: &'a I) -> Self {
9680 Self { invoker }
9681 }
9682
9683 pub async fn clear_editing_restriction(
9684 &self,
9685 params: &DocProtectionClearEditingRestrictionBoundParams,
9686 ) -> Result<DocProtectionClearEditingRestrictionResult> {
9687 self.clear_editing_restriction_with_options(params, InvokeOptions::default())
9688 .await
9689 }
9690 pub async fn clear_editing_restriction_with_options(
9691 &self,
9692 params: &DocProtectionClearEditingRestrictionBoundParams,
9693 options: InvokeOptions,
9694 ) -> Result<DocProtectionClearEditingRestrictionResult> {
9695 let params = serde_json::to_value(params)
9696 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9697 let result = self
9698 .invoker
9699 .invoke("doc.protection.clearEditingRestriction", params, options)
9700 .await?;
9701 serde_json::from_value(result).map_err(|decode| {
9702 let mut error = Error::decode(decode);
9703 error.operation_id = Some("doc.protection.clearEditingRestriction".to_owned());
9704 error.outcome_unknown = true;
9705 error
9706 })
9707 }
9708
9709 pub async fn get(
9710 &self,
9711 params: &DocProtectionGetBoundParams,
9712 ) -> Result<DocProtectionGetResult> {
9713 self.get_with_options(params, InvokeOptions::default())
9714 .await
9715 }
9716 pub async fn get_with_options(
9717 &self,
9718 params: &DocProtectionGetBoundParams,
9719 options: InvokeOptions,
9720 ) -> Result<DocProtectionGetResult> {
9721 let params = serde_json::to_value(params)
9722 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9723 let result = self
9724 .invoker
9725 .invoke("doc.protection.get", params, options)
9726 .await?;
9727 serde_json::from_value(result).map_err(|decode| {
9728 let mut error = Error::decode(decode);
9729 error.operation_id = Some("doc.protection.get".to_owned());
9730 error.outcome_unknown = false;
9731 error
9732 })
9733 }
9734
9735 pub async fn set_editing_restriction(
9736 &self,
9737 params: &DocProtectionSetEditingRestrictionBoundParams,
9738 ) -> Result<DocProtectionSetEditingRestrictionResult> {
9739 self.set_editing_restriction_with_options(params, InvokeOptions::default())
9740 .await
9741 }
9742 pub async fn set_editing_restriction_with_options(
9743 &self,
9744 params: &DocProtectionSetEditingRestrictionBoundParams,
9745 options: InvokeOptions,
9746 ) -> Result<DocProtectionSetEditingRestrictionResult> {
9747 let params = serde_json::to_value(params)
9748 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9749 let result = self
9750 .invoker
9751 .invoke("doc.protection.setEditingRestriction", params, options)
9752 .await?;
9753 serde_json::from_value(result).map_err(|decode| {
9754 let mut error = Error::decode(decode);
9755 error.operation_id = Some("doc.protection.setEditingRestriction".to_owned());
9756 error.outcome_unknown = true;
9757 error
9758 })
9759 }
9760}
9761
9762pub struct DocApiQuery<'a, I: Invoker> {
9763 invoker: &'a I,
9764}
9765impl<'a, I: Invoker> DocApiQuery<'a, I> {
9766 pub fn new(invoker: &'a I) -> Self {
9767 Self { invoker }
9768 }
9769
9770 pub async fn match_(&self, params: &DocQueryMatchBoundParams) -> Result<DocQueryMatchResult> {
9771 self.match_with_options(params, InvokeOptions::default())
9772 .await
9773 }
9774 pub async fn match_with_options(
9775 &self,
9776 params: &DocQueryMatchBoundParams,
9777 options: InvokeOptions,
9778 ) -> Result<DocQueryMatchResult> {
9779 let params = serde_json::to_value(params)
9780 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9781 let result = self
9782 .invoker
9783 .invoke("doc.query.match", params, options)
9784 .await?;
9785 serde_json::from_value(result).map_err(|decode| {
9786 let mut error = Error::decode(decode);
9787 error.operation_id = Some("doc.query.match".to_owned());
9788 error.outcome_unknown = false;
9789 error
9790 })
9791 }
9792}
9793
9794pub struct DocApiRanges<'a, I: Invoker> {
9795 invoker: &'a I,
9796}
9797impl<'a, I: Invoker> DocApiRanges<'a, I> {
9798 pub fn new(invoker: &'a I) -> Self {
9799 Self { invoker }
9800 }
9801
9802 pub async fn resolve(
9803 &self,
9804 params: &DocRangesResolveBoundParams,
9805 ) -> Result<DocRangesResolveResult> {
9806 self.resolve_with_options(params, InvokeOptions::default())
9807 .await
9808 }
9809 pub async fn resolve_with_options(
9810 &self,
9811 params: &DocRangesResolveBoundParams,
9812 options: InvokeOptions,
9813 ) -> Result<DocRangesResolveResult> {
9814 let params = serde_json::to_value(params)
9815 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9816 let result = self
9817 .invoker
9818 .invoke("doc.ranges.resolve", params, options)
9819 .await?;
9820 serde_json::from_value(result).map_err(|decode| {
9821 let mut error = Error::decode(decode);
9822 error.operation_id = Some("doc.ranges.resolve".to_owned());
9823 error.outcome_unknown = false;
9824 error
9825 })
9826 }
9827}
9828
9829pub struct DocApiSections<'a, I: Invoker> {
9830 invoker: &'a I,
9831}
9832impl<'a, I: Invoker> DocApiSections<'a, I> {
9833 pub fn new(invoker: &'a I) -> Self {
9834 Self { invoker }
9835 }
9836
9837 pub async fn clear_header_footer_ref(
9838 &self,
9839 params: &DocSectionsClearHeaderFooterRefBoundParams,
9840 ) -> Result<DocSectionsClearHeaderFooterRefResult> {
9841 self.clear_header_footer_ref_with_options(params, InvokeOptions::default())
9842 .await
9843 }
9844 pub async fn clear_header_footer_ref_with_options(
9845 &self,
9846 params: &DocSectionsClearHeaderFooterRefBoundParams,
9847 options: InvokeOptions,
9848 ) -> Result<DocSectionsClearHeaderFooterRefResult> {
9849 let params = serde_json::to_value(params)
9850 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9851 let result = self
9852 .invoker
9853 .invoke("doc.sections.clearHeaderFooterRef", params, options)
9854 .await?;
9855 serde_json::from_value(result).map_err(|decode| {
9856 let mut error = Error::decode(decode);
9857 error.operation_id = Some("doc.sections.clearHeaderFooterRef".to_owned());
9858 error.outcome_unknown = true;
9859 error
9860 })
9861 }
9862
9863 pub async fn clear_page_borders(
9864 &self,
9865 params: &DocSectionsClearPageBordersBoundParams,
9866 ) -> Result<DocSectionsClearPageBordersResult> {
9867 self.clear_page_borders_with_options(params, InvokeOptions::default())
9868 .await
9869 }
9870 pub async fn clear_page_borders_with_options(
9871 &self,
9872 params: &DocSectionsClearPageBordersBoundParams,
9873 options: InvokeOptions,
9874 ) -> Result<DocSectionsClearPageBordersResult> {
9875 let params = serde_json::to_value(params)
9876 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9877 let result = self
9878 .invoker
9879 .invoke("doc.sections.clearPageBorders", params, options)
9880 .await?;
9881 serde_json::from_value(result).map_err(|decode| {
9882 let mut error = Error::decode(decode);
9883 error.operation_id = Some("doc.sections.clearPageBorders".to_owned());
9884 error.outcome_unknown = true;
9885 error
9886 })
9887 }
9888
9889 pub async fn get(&self, params: &DocSectionsGetBoundParams) -> Result<DocSectionsGetResult> {
9890 self.get_with_options(params, InvokeOptions::default())
9891 .await
9892 }
9893 pub async fn get_with_options(
9894 &self,
9895 params: &DocSectionsGetBoundParams,
9896 options: InvokeOptions,
9897 ) -> Result<DocSectionsGetResult> {
9898 let params = serde_json::to_value(params)
9899 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9900 let result = self
9901 .invoker
9902 .invoke("doc.sections.get", params, options)
9903 .await?;
9904 serde_json::from_value(result).map_err(|decode| {
9905 let mut error = Error::decode(decode);
9906 error.operation_id = Some("doc.sections.get".to_owned());
9907 error.outcome_unknown = false;
9908 error
9909 })
9910 }
9911
9912 pub async fn list(&self, params: &DocSectionsListBoundParams) -> Result<DocSectionsListResult> {
9913 self.list_with_options(params, InvokeOptions::default())
9914 .await
9915 }
9916 pub async fn list_with_options(
9917 &self,
9918 params: &DocSectionsListBoundParams,
9919 options: InvokeOptions,
9920 ) -> Result<DocSectionsListResult> {
9921 let params = serde_json::to_value(params)
9922 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9923 let result = self
9924 .invoker
9925 .invoke("doc.sections.list", params, options)
9926 .await?;
9927 serde_json::from_value(result).map_err(|decode| {
9928 let mut error = Error::decode(decode);
9929 error.operation_id = Some("doc.sections.list".to_owned());
9930 error.outcome_unknown = false;
9931 error
9932 })
9933 }
9934
9935 pub async fn set_break_type(
9936 &self,
9937 params: &DocSectionsSetBreakTypeBoundParams,
9938 ) -> Result<DocSectionsSetBreakTypeResult> {
9939 self.set_break_type_with_options(params, InvokeOptions::default())
9940 .await
9941 }
9942 pub async fn set_break_type_with_options(
9943 &self,
9944 params: &DocSectionsSetBreakTypeBoundParams,
9945 options: InvokeOptions,
9946 ) -> Result<DocSectionsSetBreakTypeResult> {
9947 let params = serde_json::to_value(params)
9948 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9949 let result = self
9950 .invoker
9951 .invoke("doc.sections.setBreakType", params, options)
9952 .await?;
9953 serde_json::from_value(result).map_err(|decode| {
9954 let mut error = Error::decode(decode);
9955 error.operation_id = Some("doc.sections.setBreakType".to_owned());
9956 error.outcome_unknown = true;
9957 error
9958 })
9959 }
9960
9961 pub async fn set_columns(
9962 &self,
9963 params: &DocSectionsSetColumnsBoundParams,
9964 ) -> Result<DocSectionsSetColumnsResult> {
9965 self.set_columns_with_options(params, InvokeOptions::default())
9966 .await
9967 }
9968 pub async fn set_columns_with_options(
9969 &self,
9970 params: &DocSectionsSetColumnsBoundParams,
9971 options: InvokeOptions,
9972 ) -> Result<DocSectionsSetColumnsResult> {
9973 let params = serde_json::to_value(params)
9974 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
9975 let result = self
9976 .invoker
9977 .invoke("doc.sections.setColumns", params, options)
9978 .await?;
9979 serde_json::from_value(result).map_err(|decode| {
9980 let mut error = Error::decode(decode);
9981 error.operation_id = Some("doc.sections.setColumns".to_owned());
9982 error.outcome_unknown = true;
9983 error
9984 })
9985 }
9986
9987 pub async fn set_header_footer_margins(
9988 &self,
9989 params: &DocSectionsSetHeaderFooterMarginsBoundParams,
9990 ) -> Result<DocSectionsSetHeaderFooterMarginsResult> {
9991 self.set_header_footer_margins_with_options(params, InvokeOptions::default())
9992 .await
9993 }
9994 pub async fn set_header_footer_margins_with_options(
9995 &self,
9996 params: &DocSectionsSetHeaderFooterMarginsBoundParams,
9997 options: InvokeOptions,
9998 ) -> Result<DocSectionsSetHeaderFooterMarginsResult> {
9999 let params = serde_json::to_value(params)
10000 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10001 let result = self
10002 .invoker
10003 .invoke("doc.sections.setHeaderFooterMargins", params, options)
10004 .await?;
10005 serde_json::from_value(result).map_err(|decode| {
10006 let mut error = Error::decode(decode);
10007 error.operation_id = Some("doc.sections.setHeaderFooterMargins".to_owned());
10008 error.outcome_unknown = true;
10009 error
10010 })
10011 }
10012
10013 pub async fn set_header_footer_ref(
10014 &self,
10015 params: &DocSectionsSetHeaderFooterRefBoundParams,
10016 ) -> Result<DocSectionsSetHeaderFooterRefResult> {
10017 self.set_header_footer_ref_with_options(params, InvokeOptions::default())
10018 .await
10019 }
10020 pub async fn set_header_footer_ref_with_options(
10021 &self,
10022 params: &DocSectionsSetHeaderFooterRefBoundParams,
10023 options: InvokeOptions,
10024 ) -> Result<DocSectionsSetHeaderFooterRefResult> {
10025 let params = serde_json::to_value(params)
10026 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10027 let result = self
10028 .invoker
10029 .invoke("doc.sections.setHeaderFooterRef", params, options)
10030 .await?;
10031 serde_json::from_value(result).map_err(|decode| {
10032 let mut error = Error::decode(decode);
10033 error.operation_id = Some("doc.sections.setHeaderFooterRef".to_owned());
10034 error.outcome_unknown = true;
10035 error
10036 })
10037 }
10038
10039 pub async fn set_line_numbering(
10040 &self,
10041 params: &DocSectionsSetLineNumberingBoundParams,
10042 ) -> Result<DocSectionsSetLineNumberingResult> {
10043 self.set_line_numbering_with_options(params, InvokeOptions::default())
10044 .await
10045 }
10046 pub async fn set_line_numbering_with_options(
10047 &self,
10048 params: &DocSectionsSetLineNumberingBoundParams,
10049 options: InvokeOptions,
10050 ) -> Result<DocSectionsSetLineNumberingResult> {
10051 let params = serde_json::to_value(params)
10052 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10053 let result = self
10054 .invoker
10055 .invoke("doc.sections.setLineNumbering", params, options)
10056 .await?;
10057 serde_json::from_value(result).map_err(|decode| {
10058 let mut error = Error::decode(decode);
10059 error.operation_id = Some("doc.sections.setLineNumbering".to_owned());
10060 error.outcome_unknown = true;
10061 error
10062 })
10063 }
10064
10065 pub async fn set_link_to_previous(
10066 &self,
10067 params: &DocSectionsSetLinkToPreviousBoundParams,
10068 ) -> Result<DocSectionsSetLinkToPreviousResult> {
10069 self.set_link_to_previous_with_options(params, InvokeOptions::default())
10070 .await
10071 }
10072 pub async fn set_link_to_previous_with_options(
10073 &self,
10074 params: &DocSectionsSetLinkToPreviousBoundParams,
10075 options: InvokeOptions,
10076 ) -> Result<DocSectionsSetLinkToPreviousResult> {
10077 let params = serde_json::to_value(params)
10078 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10079 let result = self
10080 .invoker
10081 .invoke("doc.sections.setLinkToPrevious", params, options)
10082 .await?;
10083 serde_json::from_value(result).map_err(|decode| {
10084 let mut error = Error::decode(decode);
10085 error.operation_id = Some("doc.sections.setLinkToPrevious".to_owned());
10086 error.outcome_unknown = true;
10087 error
10088 })
10089 }
10090
10091 pub async fn set_odd_even_headers_footers(
10092 &self,
10093 params: &DocSectionsSetOddEvenHeadersFootersBoundParams,
10094 ) -> Result<DocSectionsSetOddEvenHeadersFootersResult> {
10095 self.set_odd_even_headers_footers_with_options(params, InvokeOptions::default())
10096 .await
10097 }
10098 pub async fn set_odd_even_headers_footers_with_options(
10099 &self,
10100 params: &DocSectionsSetOddEvenHeadersFootersBoundParams,
10101 options: InvokeOptions,
10102 ) -> Result<DocSectionsSetOddEvenHeadersFootersResult> {
10103 let params = serde_json::to_value(params)
10104 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10105 let result = self
10106 .invoker
10107 .invoke("doc.sections.setOddEvenHeadersFooters", params, options)
10108 .await?;
10109 serde_json::from_value(result).map_err(|decode| {
10110 let mut error = Error::decode(decode);
10111 error.operation_id = Some("doc.sections.setOddEvenHeadersFooters".to_owned());
10112 error.outcome_unknown = true;
10113 error
10114 })
10115 }
10116
10117 pub async fn set_page_borders(
10118 &self,
10119 params: &DocSectionsSetPageBordersBoundParams,
10120 ) -> Result<DocSectionsSetPageBordersResult> {
10121 self.set_page_borders_with_options(params, InvokeOptions::default())
10122 .await
10123 }
10124 pub async fn set_page_borders_with_options(
10125 &self,
10126 params: &DocSectionsSetPageBordersBoundParams,
10127 options: InvokeOptions,
10128 ) -> Result<DocSectionsSetPageBordersResult> {
10129 let params = serde_json::to_value(params)
10130 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10131 let result = self
10132 .invoker
10133 .invoke("doc.sections.setPageBorders", params, options)
10134 .await?;
10135 serde_json::from_value(result).map_err(|decode| {
10136 let mut error = Error::decode(decode);
10137 error.operation_id = Some("doc.sections.setPageBorders".to_owned());
10138 error.outcome_unknown = true;
10139 error
10140 })
10141 }
10142
10143 pub async fn set_page_margins(
10144 &self,
10145 params: &DocSectionsSetPageMarginsBoundParams,
10146 ) -> Result<DocSectionsSetPageMarginsResult> {
10147 self.set_page_margins_with_options(params, InvokeOptions::default())
10148 .await
10149 }
10150 pub async fn set_page_margins_with_options(
10151 &self,
10152 params: &DocSectionsSetPageMarginsBoundParams,
10153 options: InvokeOptions,
10154 ) -> Result<DocSectionsSetPageMarginsResult> {
10155 let params = serde_json::to_value(params)
10156 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10157 let result = self
10158 .invoker
10159 .invoke("doc.sections.setPageMargins", params, options)
10160 .await?;
10161 serde_json::from_value(result).map_err(|decode| {
10162 let mut error = Error::decode(decode);
10163 error.operation_id = Some("doc.sections.setPageMargins".to_owned());
10164 error.outcome_unknown = true;
10165 error
10166 })
10167 }
10168
10169 pub async fn set_page_numbering(
10170 &self,
10171 params: &DocSectionsSetPageNumberingBoundParams,
10172 ) -> Result<DocSectionsSetPageNumberingResult> {
10173 self.set_page_numbering_with_options(params, InvokeOptions::default())
10174 .await
10175 }
10176 pub async fn set_page_numbering_with_options(
10177 &self,
10178 params: &DocSectionsSetPageNumberingBoundParams,
10179 options: InvokeOptions,
10180 ) -> Result<DocSectionsSetPageNumberingResult> {
10181 let params = serde_json::to_value(params)
10182 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10183 let result = self
10184 .invoker
10185 .invoke("doc.sections.setPageNumbering", params, options)
10186 .await?;
10187 serde_json::from_value(result).map_err(|decode| {
10188 let mut error = Error::decode(decode);
10189 error.operation_id = Some("doc.sections.setPageNumbering".to_owned());
10190 error.outcome_unknown = true;
10191 error
10192 })
10193 }
10194
10195 pub async fn set_page_setup(
10196 &self,
10197 params: &DocSectionsSetPageSetupBoundParams,
10198 ) -> Result<DocSectionsSetPageSetupResult> {
10199 self.set_page_setup_with_options(params, InvokeOptions::default())
10200 .await
10201 }
10202 pub async fn set_page_setup_with_options(
10203 &self,
10204 params: &DocSectionsSetPageSetupBoundParams,
10205 options: InvokeOptions,
10206 ) -> Result<DocSectionsSetPageSetupResult> {
10207 let params = serde_json::to_value(params)
10208 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10209 let result = self
10210 .invoker
10211 .invoke("doc.sections.setPageSetup", params, options)
10212 .await?;
10213 serde_json::from_value(result).map_err(|decode| {
10214 let mut error = Error::decode(decode);
10215 error.operation_id = Some("doc.sections.setPageSetup".to_owned());
10216 error.outcome_unknown = true;
10217 error
10218 })
10219 }
10220
10221 pub async fn set_section_direction(
10222 &self,
10223 params: &DocSectionsSetSectionDirectionBoundParams,
10224 ) -> Result<DocSectionsSetSectionDirectionResult> {
10225 self.set_section_direction_with_options(params, InvokeOptions::default())
10226 .await
10227 }
10228 pub async fn set_section_direction_with_options(
10229 &self,
10230 params: &DocSectionsSetSectionDirectionBoundParams,
10231 options: InvokeOptions,
10232 ) -> Result<DocSectionsSetSectionDirectionResult> {
10233 let params = serde_json::to_value(params)
10234 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10235 let result = self
10236 .invoker
10237 .invoke("doc.sections.setSectionDirection", params, options)
10238 .await?;
10239 serde_json::from_value(result).map_err(|decode| {
10240 let mut error = Error::decode(decode);
10241 error.operation_id = Some("doc.sections.setSectionDirection".to_owned());
10242 error.outcome_unknown = true;
10243 error
10244 })
10245 }
10246
10247 pub async fn set_title_page(
10248 &self,
10249 params: &DocSectionsSetTitlePageBoundParams,
10250 ) -> Result<DocSectionsSetTitlePageResult> {
10251 self.set_title_page_with_options(params, InvokeOptions::default())
10252 .await
10253 }
10254 pub async fn set_title_page_with_options(
10255 &self,
10256 params: &DocSectionsSetTitlePageBoundParams,
10257 options: InvokeOptions,
10258 ) -> Result<DocSectionsSetTitlePageResult> {
10259 let params = serde_json::to_value(params)
10260 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10261 let result = self
10262 .invoker
10263 .invoke("doc.sections.setTitlePage", params, options)
10264 .await?;
10265 serde_json::from_value(result).map_err(|decode| {
10266 let mut error = Error::decode(decode);
10267 error.operation_id = Some("doc.sections.setTitlePage".to_owned());
10268 error.outcome_unknown = true;
10269 error
10270 })
10271 }
10272
10273 pub async fn set_vertical_align(
10274 &self,
10275 params: &DocSectionsSetVerticalAlignBoundParams,
10276 ) -> Result<DocSectionsSetVerticalAlignResult> {
10277 self.set_vertical_align_with_options(params, InvokeOptions::default())
10278 .await
10279 }
10280 pub async fn set_vertical_align_with_options(
10281 &self,
10282 params: &DocSectionsSetVerticalAlignBoundParams,
10283 options: InvokeOptions,
10284 ) -> Result<DocSectionsSetVerticalAlignResult> {
10285 let params = serde_json::to_value(params)
10286 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10287 let result = self
10288 .invoker
10289 .invoke("doc.sections.setVerticalAlign", params, options)
10290 .await?;
10291 serde_json::from_value(result).map_err(|decode| {
10292 let mut error = Error::decode(decode);
10293 error.operation_id = Some("doc.sections.setVerticalAlign".to_owned());
10294 error.outcome_unknown = true;
10295 error
10296 })
10297 }
10298}
10299
10300pub struct DocApiSelection<'a, I: Invoker> {
10301 invoker: &'a I,
10302}
10303impl<'a, I: Invoker> DocApiSelection<'a, I> {
10304 pub fn new(invoker: &'a I) -> Self {
10305 Self { invoker }
10306 }
10307
10308 pub async fn current(
10309 &self,
10310 params: &DocSelectionCurrentBoundParams,
10311 ) -> Result<DocSelectionCurrentResult> {
10312 self.current_with_options(params, InvokeOptions::default())
10313 .await
10314 }
10315 pub async fn current_with_options(
10316 &self,
10317 params: &DocSelectionCurrentBoundParams,
10318 options: InvokeOptions,
10319 ) -> Result<DocSelectionCurrentResult> {
10320 let params = serde_json::to_value(params)
10321 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10322 let result = self
10323 .invoker
10324 .invoke("doc.selection.current", params, options)
10325 .await?;
10326 serde_json::from_value(result).map_err(|decode| {
10327 let mut error = Error::decode(decode);
10328 error.operation_id = Some("doc.selection.current".to_owned());
10329 error.outcome_unknown = false;
10330 error
10331 })
10332 }
10333
10334 pub async fn extract_ooxml(
10335 &self,
10336 params: &DocSelectionExtractOoxmlBoundParams,
10337 ) -> Result<DocSelectionExtractOoxmlResult> {
10338 self.extract_ooxml_with_options(params, InvokeOptions::default())
10339 .await
10340 }
10341 pub async fn extract_ooxml_with_options(
10342 &self,
10343 params: &DocSelectionExtractOoxmlBoundParams,
10344 options: InvokeOptions,
10345 ) -> Result<DocSelectionExtractOoxmlResult> {
10346 let params = serde_json::to_value(params)
10347 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10348 let result = self
10349 .invoker
10350 .invoke("doc.selection.extractOoxml", params, options)
10351 .await?;
10352 serde_json::from_value(result).map_err(|decode| {
10353 let mut error = Error::decode(decode);
10354 error.operation_id = Some("doc.selection.extractOoxml".to_owned());
10355 error.outcome_unknown = false;
10356 error
10357 })
10358 }
10359
10360 pub async fn release_snapshot(
10361 &self,
10362 params: &DocSelectionReleaseSnapshotBoundParams,
10363 ) -> Result<DocSelectionReleaseSnapshotResult> {
10364 self.release_snapshot_with_options(params, InvokeOptions::default())
10365 .await
10366 }
10367 pub async fn release_snapshot_with_options(
10368 &self,
10369 params: &DocSelectionReleaseSnapshotBoundParams,
10370 options: InvokeOptions,
10371 ) -> Result<DocSelectionReleaseSnapshotResult> {
10372 let params = serde_json::to_value(params)
10373 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10374 let result = self
10375 .invoker
10376 .invoke("doc.selection.releaseSnapshot", params, options)
10377 .await?;
10378 serde_json::from_value(result).map_err(|decode| {
10379 let mut error = Error::decode(decode);
10380 error.operation_id = Some("doc.selection.releaseSnapshot".to_owned());
10381 error.outcome_unknown = false;
10382 error
10383 })
10384 }
10385}
10386
10387pub struct DocApiStyles<'a, I: Invoker> {
10388 invoker: &'a I,
10389}
10390impl<'a, I: Invoker> DocApiStyles<'a, I> {
10391 pub fn new(invoker: &'a I) -> Self {
10392 Self { invoker }
10393 }
10394 pub fn paragraph(&self) -> DocApiStylesParagraph<'a, I> {
10395 DocApiStylesParagraph::new(self.invoker)
10396 }
10397
10398 pub async fn apply(&self, params: &DocStylesApplyBoundParams) -> Result<DocStylesApplyResult> {
10399 self.apply_with_options(params, InvokeOptions::default())
10400 .await
10401 }
10402 pub async fn apply_with_options(
10403 &self,
10404 params: &DocStylesApplyBoundParams,
10405 options: InvokeOptions,
10406 ) -> Result<DocStylesApplyResult> {
10407 let params = serde_json::to_value(params)
10408 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10409 let result = self
10410 .invoker
10411 .invoke("doc.styles.apply", params, options)
10412 .await?;
10413 serde_json::from_value(result).map_err(|decode| {
10414 let mut error = Error::decode(decode);
10415 error.operation_id = Some("doc.styles.apply".to_owned());
10416 error.outcome_unknown = true;
10417 error
10418 })
10419 }
10420
10421 pub async fn create(
10422 &self,
10423 params: &DocStylesCreateBoundParams,
10424 ) -> Result<DocStylesCreateResult> {
10425 self.create_with_options(params, InvokeOptions::default())
10426 .await
10427 }
10428 pub async fn create_with_options(
10429 &self,
10430 params: &DocStylesCreateBoundParams,
10431 options: InvokeOptions,
10432 ) -> Result<DocStylesCreateResult> {
10433 let params = serde_json::to_value(params)
10434 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10435 let result = self
10436 .invoker
10437 .invoke("doc.styles.create", params, options)
10438 .await?;
10439 serde_json::from_value(result).map_err(|decode| {
10440 let mut error = Error::decode(decode);
10441 error.operation_id = Some("doc.styles.create".to_owned());
10442 error.outcome_unknown = true;
10443 error
10444 })
10445 }
10446
10447 pub async fn get_catalog(
10448 &self,
10449 params: &DocStylesGetCatalogBoundParams,
10450 ) -> Result<DocStylesGetCatalogResult> {
10451 self.get_catalog_with_options(params, InvokeOptions::default())
10452 .await
10453 }
10454 pub async fn get_catalog_with_options(
10455 &self,
10456 params: &DocStylesGetCatalogBoundParams,
10457 options: InvokeOptions,
10458 ) -> Result<DocStylesGetCatalogResult> {
10459 let params = serde_json::to_value(params)
10460 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10461 let result = self
10462 .invoker
10463 .invoke("doc.styles.getCatalog", params, options)
10464 .await?;
10465 serde_json::from_value(result).map_err(|decode| {
10466 let mut error = Error::decode(decode);
10467 error.operation_id = Some("doc.styles.getCatalog".to_owned());
10468 error.outcome_unknown = false;
10469 error
10470 })
10471 }
10472
10473 pub async fn get_theme(
10474 &self,
10475 params: &DocStylesGetThemeBoundParams,
10476 ) -> Result<DocStylesGetThemeResult> {
10477 self.get_theme_with_options(params, InvokeOptions::default())
10478 .await
10479 }
10480 pub async fn get_theme_with_options(
10481 &self,
10482 params: &DocStylesGetThemeBoundParams,
10483 options: InvokeOptions,
10484 ) -> Result<DocStylesGetThemeResult> {
10485 let params = serde_json::to_value(params)
10486 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10487 let result = self
10488 .invoker
10489 .invoke("doc.styles.getTheme", params, options)
10490 .await?;
10491 serde_json::from_value(result).map_err(|decode| {
10492 let mut error = Error::decode(decode);
10493 error.operation_id = Some("doc.styles.getTheme".to_owned());
10494 error.outcome_unknown = false;
10495 error
10496 })
10497 }
10498}
10499
10500pub struct DocApiStylesParagraph<'a, I: Invoker> {
10501 invoker: &'a I,
10502}
10503impl<'a, I: Invoker> DocApiStylesParagraph<'a, I> {
10504 pub fn new(invoker: &'a I) -> Self {
10505 Self { invoker }
10506 }
10507
10508 pub async fn clear_style(
10509 &self,
10510 params: &DocStylesParagraphClearStyleBoundParams,
10511 ) -> Result<DocStylesParagraphClearStyleResult> {
10512 self.clear_style_with_options(params, InvokeOptions::default())
10513 .await
10514 }
10515 pub async fn clear_style_with_options(
10516 &self,
10517 params: &DocStylesParagraphClearStyleBoundParams,
10518 options: InvokeOptions,
10519 ) -> Result<DocStylesParagraphClearStyleResult> {
10520 let params = serde_json::to_value(params)
10521 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10522 let result = self
10523 .invoker
10524 .invoke("doc.styles.paragraph.clearStyle", params, options)
10525 .await?;
10526 serde_json::from_value(result).map_err(|decode| {
10527 let mut error = Error::decode(decode);
10528 error.operation_id = Some("doc.styles.paragraph.clearStyle".to_owned());
10529 error.outcome_unknown = true;
10530 error
10531 })
10532 }
10533
10534 pub async fn set_style(
10535 &self,
10536 params: &DocStylesParagraphSetStyleBoundParams,
10537 ) -> Result<DocStylesParagraphSetStyleResult> {
10538 self.set_style_with_options(params, InvokeOptions::default())
10539 .await
10540 }
10541 pub async fn set_style_with_options(
10542 &self,
10543 params: &DocStylesParagraphSetStyleBoundParams,
10544 options: InvokeOptions,
10545 ) -> Result<DocStylesParagraphSetStyleResult> {
10546 let params = serde_json::to_value(params)
10547 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10548 let result = self
10549 .invoker
10550 .invoke("doc.styles.paragraph.setStyle", params, options)
10551 .await?;
10552 serde_json::from_value(result).map_err(|decode| {
10553 let mut error = Error::decode(decode);
10554 error.operation_id = Some("doc.styles.paragraph.setStyle".to_owned());
10555 error.outcome_unknown = true;
10556 error
10557 })
10558 }
10559
10560 pub async fn set_style_ref(
10561 &self,
10562 params: &DocStylesParagraphSetStyleRefBoundParams,
10563 ) -> Result<DocStylesParagraphSetStyleRefResult> {
10564 self.set_style_ref_with_options(params, InvokeOptions::default())
10565 .await
10566 }
10567 pub async fn set_style_ref_with_options(
10568 &self,
10569 params: &DocStylesParagraphSetStyleRefBoundParams,
10570 options: InvokeOptions,
10571 ) -> Result<DocStylesParagraphSetStyleRefResult> {
10572 let params = serde_json::to_value(params)
10573 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10574 let result = self
10575 .invoker
10576 .invoke("doc.styles.paragraph.setStyleRef", params, options)
10577 .await?;
10578 serde_json::from_value(result).map_err(|decode| {
10579 let mut error = Error::decode(decode);
10580 error.operation_id = Some("doc.styles.paragraph.setStyleRef".to_owned());
10581 error.outcome_unknown = true;
10582 error
10583 })
10584 }
10585}
10586
10587pub struct DocApiTables<'a, I: Invoker> {
10588 invoker: &'a I,
10589}
10590impl<'a, I: Invoker> DocApiTables<'a, I> {
10591 pub fn new(invoker: &'a I) -> Self {
10592 Self { invoker }
10593 }
10594
10595 pub async fn apply_border_preset(
10596 &self,
10597 params: &DocTablesApplyBorderPresetBoundParams,
10598 ) -> Result<DocTablesApplyBorderPresetResult> {
10599 self.apply_border_preset_with_options(params, InvokeOptions::default())
10600 .await
10601 }
10602 pub async fn apply_border_preset_with_options(
10603 &self,
10604 params: &DocTablesApplyBorderPresetBoundParams,
10605 options: InvokeOptions,
10606 ) -> Result<DocTablesApplyBorderPresetResult> {
10607 let params = serde_json::to_value(params)
10608 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10609 let result = self
10610 .invoker
10611 .invoke("doc.tables.applyBorderPreset", params, options)
10612 .await?;
10613 serde_json::from_value(result).map_err(|decode| {
10614 let mut error = Error::decode(decode);
10615 error.operation_id = Some("doc.tables.applyBorderPreset".to_owned());
10616 error.outcome_unknown = true;
10617 error
10618 })
10619 }
10620
10621 pub async fn apply_preset(
10622 &self,
10623 params: &DocTablesApplyPresetBoundParams,
10624 ) -> Result<DocTablesApplyPresetResult> {
10625 self.apply_preset_with_options(params, InvokeOptions::default())
10626 .await
10627 }
10628 pub async fn apply_preset_with_options(
10629 &self,
10630 params: &DocTablesApplyPresetBoundParams,
10631 options: InvokeOptions,
10632 ) -> Result<DocTablesApplyPresetResult> {
10633 let params = serde_json::to_value(params)
10634 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10635 let result = self
10636 .invoker
10637 .invoke("doc.tables.applyPreset", params, options)
10638 .await?;
10639 serde_json::from_value(result).map_err(|decode| {
10640 let mut error = Error::decode(decode);
10641 error.operation_id = Some("doc.tables.applyPreset".to_owned());
10642 error.outcome_unknown = true;
10643 error
10644 })
10645 }
10646
10647 pub async fn apply_style(
10648 &self,
10649 params: &DocTablesApplyStyleBoundParams,
10650 ) -> Result<DocTablesApplyStyleResult> {
10651 self.apply_style_with_options(params, InvokeOptions::default())
10652 .await
10653 }
10654 pub async fn apply_style_with_options(
10655 &self,
10656 params: &DocTablesApplyStyleBoundParams,
10657 options: InvokeOptions,
10658 ) -> Result<DocTablesApplyStyleResult> {
10659 let params = serde_json::to_value(params)
10660 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10661 let result = self
10662 .invoker
10663 .invoke("doc.tables.applyStyle", params, options)
10664 .await?;
10665 serde_json::from_value(result).map_err(|decode| {
10666 let mut error = Error::decode(decode);
10667 error.operation_id = Some("doc.tables.applyStyle".to_owned());
10668 error.outcome_unknown = true;
10669 error
10670 })
10671 }
10672
10673 pub async fn clear_border(
10674 &self,
10675 params: &DocTablesClearBorderBoundParams,
10676 ) -> Result<DocTablesClearBorderResult> {
10677 self.clear_border_with_options(params, InvokeOptions::default())
10678 .await
10679 }
10680 pub async fn clear_border_with_options(
10681 &self,
10682 params: &DocTablesClearBorderBoundParams,
10683 options: InvokeOptions,
10684 ) -> Result<DocTablesClearBorderResult> {
10685 let params = serde_json::to_value(params)
10686 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10687 let result = self
10688 .invoker
10689 .invoke("doc.tables.clearBorder", params, options)
10690 .await?;
10691 serde_json::from_value(result).map_err(|decode| {
10692 let mut error = Error::decode(decode);
10693 error.operation_id = Some("doc.tables.clearBorder".to_owned());
10694 error.outcome_unknown = true;
10695 error
10696 })
10697 }
10698
10699 pub async fn clear_cell_spacing(
10700 &self,
10701 params: &DocTablesClearCellSpacingBoundParams,
10702 ) -> Result<DocTablesClearCellSpacingResult> {
10703 self.clear_cell_spacing_with_options(params, InvokeOptions::default())
10704 .await
10705 }
10706 pub async fn clear_cell_spacing_with_options(
10707 &self,
10708 params: &DocTablesClearCellSpacingBoundParams,
10709 options: InvokeOptions,
10710 ) -> Result<DocTablesClearCellSpacingResult> {
10711 let params = serde_json::to_value(params)
10712 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10713 let result = self
10714 .invoker
10715 .invoke("doc.tables.clearCellSpacing", params, options)
10716 .await?;
10717 serde_json::from_value(result).map_err(|decode| {
10718 let mut error = Error::decode(decode);
10719 error.operation_id = Some("doc.tables.clearCellSpacing".to_owned());
10720 error.outcome_unknown = true;
10721 error
10722 })
10723 }
10724
10725 pub async fn clear_contents(
10726 &self,
10727 params: &DocTablesClearContentsBoundParams,
10728 ) -> Result<DocTablesClearContentsResult> {
10729 self.clear_contents_with_options(params, InvokeOptions::default())
10730 .await
10731 }
10732 pub async fn clear_contents_with_options(
10733 &self,
10734 params: &DocTablesClearContentsBoundParams,
10735 options: InvokeOptions,
10736 ) -> Result<DocTablesClearContentsResult> {
10737 let params = serde_json::to_value(params)
10738 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10739 let result = self
10740 .invoker
10741 .invoke("doc.tables.clearContents", params, options)
10742 .await?;
10743 serde_json::from_value(result).map_err(|decode| {
10744 let mut error = Error::decode(decode);
10745 error.operation_id = Some("doc.tables.clearContents".to_owned());
10746 error.outcome_unknown = true;
10747 error
10748 })
10749 }
10750
10751 pub async fn clear_default_style(
10752 &self,
10753 params: &DocTablesClearDefaultStyleBoundParams,
10754 ) -> Result<DocTablesClearDefaultStyleResult> {
10755 self.clear_default_style_with_options(params, InvokeOptions::default())
10756 .await
10757 }
10758 pub async fn clear_default_style_with_options(
10759 &self,
10760 params: &DocTablesClearDefaultStyleBoundParams,
10761 options: InvokeOptions,
10762 ) -> Result<DocTablesClearDefaultStyleResult> {
10763 let params = serde_json::to_value(params)
10764 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10765 let result = self
10766 .invoker
10767 .invoke("doc.tables.clearDefaultStyle", params, options)
10768 .await?;
10769 serde_json::from_value(result).map_err(|decode| {
10770 let mut error = Error::decode(decode);
10771 error.operation_id = Some("doc.tables.clearDefaultStyle".to_owned());
10772 error.outcome_unknown = true;
10773 error
10774 })
10775 }
10776
10777 pub async fn clear_shading(
10778 &self,
10779 params: &DocTablesClearShadingBoundParams,
10780 ) -> Result<DocTablesClearShadingResult> {
10781 self.clear_shading_with_options(params, InvokeOptions::default())
10782 .await
10783 }
10784 pub async fn clear_shading_with_options(
10785 &self,
10786 params: &DocTablesClearShadingBoundParams,
10787 options: InvokeOptions,
10788 ) -> Result<DocTablesClearShadingResult> {
10789 let params = serde_json::to_value(params)
10790 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10791 let result = self
10792 .invoker
10793 .invoke("doc.tables.clearShading", params, options)
10794 .await?;
10795 serde_json::from_value(result).map_err(|decode| {
10796 let mut error = Error::decode(decode);
10797 error.operation_id = Some("doc.tables.clearShading".to_owned());
10798 error.outcome_unknown = true;
10799 error
10800 })
10801 }
10802
10803 pub async fn clear_style(
10804 &self,
10805 params: &DocTablesClearStyleBoundParams,
10806 ) -> Result<DocTablesClearStyleResult> {
10807 self.clear_style_with_options(params, InvokeOptions::default())
10808 .await
10809 }
10810 pub async fn clear_style_with_options(
10811 &self,
10812 params: &DocTablesClearStyleBoundParams,
10813 options: InvokeOptions,
10814 ) -> Result<DocTablesClearStyleResult> {
10815 let params = serde_json::to_value(params)
10816 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10817 let result = self
10818 .invoker
10819 .invoke("doc.tables.clearStyle", params, options)
10820 .await?;
10821 serde_json::from_value(result).map_err(|decode| {
10822 let mut error = Error::decode(decode);
10823 error.operation_id = Some("doc.tables.clearStyle".to_owned());
10824 error.outcome_unknown = true;
10825 error
10826 })
10827 }
10828
10829 pub async fn convert_from_text(
10830 &self,
10831 params: &DocTablesConvertFromTextBoundParams,
10832 ) -> Result<DocTablesConvertFromTextResult> {
10833 self.convert_from_text_with_options(params, InvokeOptions::default())
10834 .await
10835 }
10836 pub async fn convert_from_text_with_options(
10837 &self,
10838 params: &DocTablesConvertFromTextBoundParams,
10839 options: InvokeOptions,
10840 ) -> Result<DocTablesConvertFromTextResult> {
10841 let params = serde_json::to_value(params)
10842 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10843 let result = self
10844 .invoker
10845 .invoke("doc.tables.convertFromText", params, options)
10846 .await?;
10847 serde_json::from_value(result).map_err(|decode| {
10848 let mut error = Error::decode(decode);
10849 error.operation_id = Some("doc.tables.convertFromText".to_owned());
10850 error.outcome_unknown = true;
10851 error
10852 })
10853 }
10854
10855 pub async fn convert_to_text(
10856 &self,
10857 params: &DocTablesConvertToTextBoundParams,
10858 ) -> Result<DocTablesConvertToTextResult> {
10859 self.convert_to_text_with_options(params, InvokeOptions::default())
10860 .await
10861 }
10862 pub async fn convert_to_text_with_options(
10863 &self,
10864 params: &DocTablesConvertToTextBoundParams,
10865 options: InvokeOptions,
10866 ) -> Result<DocTablesConvertToTextResult> {
10867 let params = serde_json::to_value(params)
10868 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10869 let result = self
10870 .invoker
10871 .invoke("doc.tables.convertToText", params, options)
10872 .await?;
10873 serde_json::from_value(result).map_err(|decode| {
10874 let mut error = Error::decode(decode);
10875 error.operation_id = Some("doc.tables.convertToText".to_owned());
10876 error.outcome_unknown = true;
10877 error
10878 })
10879 }
10880
10881 pub async fn delete(
10882 &self,
10883 params: &DocTablesDeleteBoundParams,
10884 ) -> Result<DocTablesDeleteResult> {
10885 self.delete_with_options(params, InvokeOptions::default())
10886 .await
10887 }
10888 pub async fn delete_with_options(
10889 &self,
10890 params: &DocTablesDeleteBoundParams,
10891 options: InvokeOptions,
10892 ) -> Result<DocTablesDeleteResult> {
10893 let params = serde_json::to_value(params)
10894 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10895 let result = self
10896 .invoker
10897 .invoke("doc.tables.delete", params, options)
10898 .await?;
10899 serde_json::from_value(result).map_err(|decode| {
10900 let mut error = Error::decode(decode);
10901 error.operation_id = Some("doc.tables.delete".to_owned());
10902 error.outcome_unknown = true;
10903 error
10904 })
10905 }
10906
10907 pub async fn delete_cell(
10908 &self,
10909 params: &DocTablesDeleteCellBoundParams,
10910 ) -> Result<DocTablesDeleteCellResult> {
10911 self.delete_cell_with_options(params, InvokeOptions::default())
10912 .await
10913 }
10914 pub async fn delete_cell_with_options(
10915 &self,
10916 params: &DocTablesDeleteCellBoundParams,
10917 options: InvokeOptions,
10918 ) -> Result<DocTablesDeleteCellResult> {
10919 let params = serde_json::to_value(params)
10920 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10921 let result = self
10922 .invoker
10923 .invoke("doc.tables.deleteCell", params, options)
10924 .await?;
10925 serde_json::from_value(result).map_err(|decode| {
10926 let mut error = Error::decode(decode);
10927 error.operation_id = Some("doc.tables.deleteCell".to_owned());
10928 error.outcome_unknown = true;
10929 error
10930 })
10931 }
10932
10933 pub async fn delete_column(
10934 &self,
10935 params: &DocTablesDeleteColumnBoundParams,
10936 ) -> Result<DocTablesDeleteColumnResult> {
10937 self.delete_column_with_options(params, InvokeOptions::default())
10938 .await
10939 }
10940 pub async fn delete_column_with_options(
10941 &self,
10942 params: &DocTablesDeleteColumnBoundParams,
10943 options: InvokeOptions,
10944 ) -> Result<DocTablesDeleteColumnResult> {
10945 let params = serde_json::to_value(params)
10946 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10947 let result = self
10948 .invoker
10949 .invoke("doc.tables.deleteColumn", params, options)
10950 .await?;
10951 serde_json::from_value(result).map_err(|decode| {
10952 let mut error = Error::decode(decode);
10953 error.operation_id = Some("doc.tables.deleteColumn".to_owned());
10954 error.outcome_unknown = true;
10955 error
10956 })
10957 }
10958
10959 pub async fn delete_row(
10960 &self,
10961 params: &DocTablesDeleteRowBoundParams,
10962 ) -> Result<DocTablesDeleteRowResult> {
10963 self.delete_row_with_options(params, InvokeOptions::default())
10964 .await
10965 }
10966 pub async fn delete_row_with_options(
10967 &self,
10968 params: &DocTablesDeleteRowBoundParams,
10969 options: InvokeOptions,
10970 ) -> Result<DocTablesDeleteRowResult> {
10971 let params = serde_json::to_value(params)
10972 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10973 let result = self
10974 .invoker
10975 .invoke("doc.tables.deleteRow", params, options)
10976 .await?;
10977 serde_json::from_value(result).map_err(|decode| {
10978 let mut error = Error::decode(decode);
10979 error.operation_id = Some("doc.tables.deleteRow".to_owned());
10980 error.outcome_unknown = true;
10981 error
10982 })
10983 }
10984
10985 pub async fn distribute_columns(
10986 &self,
10987 params: &DocTablesDistributeColumnsBoundParams,
10988 ) -> Result<DocTablesDistributeColumnsResult> {
10989 self.distribute_columns_with_options(params, InvokeOptions::default())
10990 .await
10991 }
10992 pub async fn distribute_columns_with_options(
10993 &self,
10994 params: &DocTablesDistributeColumnsBoundParams,
10995 options: InvokeOptions,
10996 ) -> Result<DocTablesDistributeColumnsResult> {
10997 let params = serde_json::to_value(params)
10998 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
10999 let result = self
11000 .invoker
11001 .invoke("doc.tables.distributeColumns", params, options)
11002 .await?;
11003 serde_json::from_value(result).map_err(|decode| {
11004 let mut error = Error::decode(decode);
11005 error.operation_id = Some("doc.tables.distributeColumns".to_owned());
11006 error.outcome_unknown = true;
11007 error
11008 })
11009 }
11010
11011 pub async fn distribute_rows(
11012 &self,
11013 params: &DocTablesDistributeRowsBoundParams,
11014 ) -> Result<DocTablesDistributeRowsResult> {
11015 self.distribute_rows_with_options(params, InvokeOptions::default())
11016 .await
11017 }
11018 pub async fn distribute_rows_with_options(
11019 &self,
11020 params: &DocTablesDistributeRowsBoundParams,
11021 options: InvokeOptions,
11022 ) -> Result<DocTablesDistributeRowsResult> {
11023 let params = serde_json::to_value(params)
11024 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11025 let result = self
11026 .invoker
11027 .invoke("doc.tables.distributeRows", params, options)
11028 .await?;
11029 serde_json::from_value(result).map_err(|decode| {
11030 let mut error = Error::decode(decode);
11031 error.operation_id = Some("doc.tables.distributeRows".to_owned());
11032 error.outcome_unknown = true;
11033 error
11034 })
11035 }
11036
11037 pub async fn get(&self, params: &DocTablesGetBoundParams) -> Result<DocTablesGetResult> {
11038 self.get_with_options(params, InvokeOptions::default())
11039 .await
11040 }
11041 pub async fn get_with_options(
11042 &self,
11043 params: &DocTablesGetBoundParams,
11044 options: InvokeOptions,
11045 ) -> Result<DocTablesGetResult> {
11046 let params = serde_json::to_value(params)
11047 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11048 let result = self
11049 .invoker
11050 .invoke("doc.tables.get", params, options)
11051 .await?;
11052 serde_json::from_value(result).map_err(|decode| {
11053 let mut error = Error::decode(decode);
11054 error.operation_id = Some("doc.tables.get".to_owned());
11055 error.outcome_unknown = false;
11056 error
11057 })
11058 }
11059
11060 pub async fn get_cells(
11061 &self,
11062 params: &DocTablesGetCellsBoundParams,
11063 ) -> Result<DocTablesGetCellsResult> {
11064 self.get_cells_with_options(params, InvokeOptions::default())
11065 .await
11066 }
11067 pub async fn get_cells_with_options(
11068 &self,
11069 params: &DocTablesGetCellsBoundParams,
11070 options: InvokeOptions,
11071 ) -> Result<DocTablesGetCellsResult> {
11072 let params = serde_json::to_value(params)
11073 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11074 let result = self
11075 .invoker
11076 .invoke("doc.tables.getCells", params, options)
11077 .await?;
11078 serde_json::from_value(result).map_err(|decode| {
11079 let mut error = Error::decode(decode);
11080 error.operation_id = Some("doc.tables.getCells".to_owned());
11081 error.outcome_unknown = false;
11082 error
11083 })
11084 }
11085
11086 pub async fn get_properties(
11087 &self,
11088 params: &DocTablesGetPropertiesBoundParams,
11089 ) -> Result<DocTablesGetPropertiesResult> {
11090 self.get_properties_with_options(params, InvokeOptions::default())
11091 .await
11092 }
11093 pub async fn get_properties_with_options(
11094 &self,
11095 params: &DocTablesGetPropertiesBoundParams,
11096 options: InvokeOptions,
11097 ) -> Result<DocTablesGetPropertiesResult> {
11098 let params = serde_json::to_value(params)
11099 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11100 let result = self
11101 .invoker
11102 .invoke("doc.tables.getProperties", params, options)
11103 .await?;
11104 serde_json::from_value(result).map_err(|decode| {
11105 let mut error = Error::decode(decode);
11106 error.operation_id = Some("doc.tables.getProperties".to_owned());
11107 error.outcome_unknown = false;
11108 error
11109 })
11110 }
11111
11112 pub async fn get_styles(
11113 &self,
11114 params: &DocTablesGetStylesBoundParams,
11115 ) -> Result<DocTablesGetStylesResult> {
11116 self.get_styles_with_options(params, InvokeOptions::default())
11117 .await
11118 }
11119 pub async fn get_styles_with_options(
11120 &self,
11121 params: &DocTablesGetStylesBoundParams,
11122 options: InvokeOptions,
11123 ) -> Result<DocTablesGetStylesResult> {
11124 let params = serde_json::to_value(params)
11125 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11126 let result = self
11127 .invoker
11128 .invoke("doc.tables.getStyles", params, options)
11129 .await?;
11130 serde_json::from_value(result).map_err(|decode| {
11131 let mut error = Error::decode(decode);
11132 error.operation_id = Some("doc.tables.getStyles".to_owned());
11133 error.outcome_unknown = false;
11134 error
11135 })
11136 }
11137
11138 pub async fn insert_cell(
11139 &self,
11140 params: &DocTablesInsertCellBoundParams,
11141 ) -> Result<DocTablesInsertCellResult> {
11142 self.insert_cell_with_options(params, InvokeOptions::default())
11143 .await
11144 }
11145 pub async fn insert_cell_with_options(
11146 &self,
11147 params: &DocTablesInsertCellBoundParams,
11148 options: InvokeOptions,
11149 ) -> Result<DocTablesInsertCellResult> {
11150 let params = serde_json::to_value(params)
11151 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11152 let result = self
11153 .invoker
11154 .invoke("doc.tables.insertCell", params, options)
11155 .await?;
11156 serde_json::from_value(result).map_err(|decode| {
11157 let mut error = Error::decode(decode);
11158 error.operation_id = Some("doc.tables.insertCell".to_owned());
11159 error.outcome_unknown = true;
11160 error
11161 })
11162 }
11163
11164 pub async fn insert_column(
11165 &self,
11166 params: &DocTablesInsertColumnBoundParams,
11167 ) -> Result<DocTablesInsertColumnResult> {
11168 self.insert_column_with_options(params, InvokeOptions::default())
11169 .await
11170 }
11171 pub async fn insert_column_with_options(
11172 &self,
11173 params: &DocTablesInsertColumnBoundParams,
11174 options: InvokeOptions,
11175 ) -> Result<DocTablesInsertColumnResult> {
11176 let params = serde_json::to_value(params)
11177 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11178 let result = self
11179 .invoker
11180 .invoke("doc.tables.insertColumn", params, options)
11181 .await?;
11182 serde_json::from_value(result).map_err(|decode| {
11183 let mut error = Error::decode(decode);
11184 error.operation_id = Some("doc.tables.insertColumn".to_owned());
11185 error.outcome_unknown = true;
11186 error
11187 })
11188 }
11189
11190 pub async fn insert_row(
11191 &self,
11192 params: &DocTablesInsertRowBoundParams,
11193 ) -> Result<DocTablesInsertRowResult> {
11194 self.insert_row_with_options(params, InvokeOptions::default())
11195 .await
11196 }
11197 pub async fn insert_row_with_options(
11198 &self,
11199 params: &DocTablesInsertRowBoundParams,
11200 options: InvokeOptions,
11201 ) -> Result<DocTablesInsertRowResult> {
11202 let params = serde_json::to_value(params)
11203 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11204 let result = self
11205 .invoker
11206 .invoke("doc.tables.insertRow", params, options)
11207 .await?;
11208 serde_json::from_value(result).map_err(|decode| {
11209 let mut error = Error::decode(decode);
11210 error.operation_id = Some("doc.tables.insertRow".to_owned());
11211 error.outcome_unknown = true;
11212 error
11213 })
11214 }
11215
11216 pub async fn merge_cells(
11217 &self,
11218 params: &DocTablesMergeCellsBoundParams,
11219 ) -> Result<DocTablesMergeCellsResult> {
11220 self.merge_cells_with_options(params, InvokeOptions::default())
11221 .await
11222 }
11223 pub async fn merge_cells_with_options(
11224 &self,
11225 params: &DocTablesMergeCellsBoundParams,
11226 options: InvokeOptions,
11227 ) -> Result<DocTablesMergeCellsResult> {
11228 let params = serde_json::to_value(params)
11229 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11230 let result = self
11231 .invoker
11232 .invoke("doc.tables.mergeCells", params, options)
11233 .await?;
11234 serde_json::from_value(result).map_err(|decode| {
11235 let mut error = Error::decode(decode);
11236 error.operation_id = Some("doc.tables.mergeCells".to_owned());
11237 error.outcome_unknown = true;
11238 error
11239 })
11240 }
11241
11242 pub async fn move_(&self, params: &DocTablesMoveBoundParams) -> Result<DocTablesMoveResult> {
11243 self.move_with_options(params, InvokeOptions::default())
11244 .await
11245 }
11246 pub async fn move_with_options(
11247 &self,
11248 params: &DocTablesMoveBoundParams,
11249 options: InvokeOptions,
11250 ) -> Result<DocTablesMoveResult> {
11251 let params = serde_json::to_value(params)
11252 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11253 let result = self
11254 .invoker
11255 .invoke("doc.tables.move", params, options)
11256 .await?;
11257 serde_json::from_value(result).map_err(|decode| {
11258 let mut error = Error::decode(decode);
11259 error.operation_id = Some("doc.tables.move".to_owned());
11260 error.outcome_unknown = true;
11261 error
11262 })
11263 }
11264
11265 pub async fn move_column(
11266 &self,
11267 params: &DocTablesMoveColumnBoundParams,
11268 ) -> Result<DocTablesMoveColumnResult> {
11269 self.move_column_with_options(params, InvokeOptions::default())
11270 .await
11271 }
11272 pub async fn move_column_with_options(
11273 &self,
11274 params: &DocTablesMoveColumnBoundParams,
11275 options: InvokeOptions,
11276 ) -> Result<DocTablesMoveColumnResult> {
11277 let params = serde_json::to_value(params)
11278 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11279 let result = self
11280 .invoker
11281 .invoke("doc.tables.moveColumn", params, options)
11282 .await?;
11283 serde_json::from_value(result).map_err(|decode| {
11284 let mut error = Error::decode(decode);
11285 error.operation_id = Some("doc.tables.moveColumn".to_owned());
11286 error.outcome_unknown = true;
11287 error
11288 })
11289 }
11290
11291 pub async fn move_row(
11292 &self,
11293 params: &DocTablesMoveRowBoundParams,
11294 ) -> Result<DocTablesMoveRowResult> {
11295 self.move_row_with_options(params, InvokeOptions::default())
11296 .await
11297 }
11298 pub async fn move_row_with_options(
11299 &self,
11300 params: &DocTablesMoveRowBoundParams,
11301 options: InvokeOptions,
11302 ) -> Result<DocTablesMoveRowResult> {
11303 let params = serde_json::to_value(params)
11304 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11305 let result = self
11306 .invoker
11307 .invoke("doc.tables.moveRow", params, options)
11308 .await?;
11309 serde_json::from_value(result).map_err(|decode| {
11310 let mut error = Error::decode(decode);
11311 error.operation_id = Some("doc.tables.moveRow".to_owned());
11312 error.outcome_unknown = true;
11313 error
11314 })
11315 }
11316
11317 pub async fn set_alt_text(
11318 &self,
11319 params: &DocTablesSetAltTextBoundParams,
11320 ) -> Result<DocTablesSetAltTextResult> {
11321 self.set_alt_text_with_options(params, InvokeOptions::default())
11322 .await
11323 }
11324 pub async fn set_alt_text_with_options(
11325 &self,
11326 params: &DocTablesSetAltTextBoundParams,
11327 options: InvokeOptions,
11328 ) -> Result<DocTablesSetAltTextResult> {
11329 let params = serde_json::to_value(params)
11330 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11331 let result = self
11332 .invoker
11333 .invoke("doc.tables.setAltText", params, options)
11334 .await?;
11335 serde_json::from_value(result).map_err(|decode| {
11336 let mut error = Error::decode(decode);
11337 error.operation_id = Some("doc.tables.setAltText".to_owned());
11338 error.outcome_unknown = true;
11339 error
11340 })
11341 }
11342
11343 pub async fn set_border(
11344 &self,
11345 params: &DocTablesSetBorderBoundParams,
11346 ) -> Result<DocTablesSetBorderResult> {
11347 self.set_border_with_options(params, InvokeOptions::default())
11348 .await
11349 }
11350 pub async fn set_border_with_options(
11351 &self,
11352 params: &DocTablesSetBorderBoundParams,
11353 options: InvokeOptions,
11354 ) -> Result<DocTablesSetBorderResult> {
11355 let params = serde_json::to_value(params)
11356 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11357 let result = self
11358 .invoker
11359 .invoke("doc.tables.setBorder", params, options)
11360 .await?;
11361 serde_json::from_value(result).map_err(|decode| {
11362 let mut error = Error::decode(decode);
11363 error.operation_id = Some("doc.tables.setBorder".to_owned());
11364 error.outcome_unknown = true;
11365 error
11366 })
11367 }
11368
11369 pub async fn set_borders(
11370 &self,
11371 params: &DocTablesSetBordersBoundParams,
11372 ) -> Result<DocTablesSetBordersResult> {
11373 self.set_borders_with_options(params, InvokeOptions::default())
11374 .await
11375 }
11376 pub async fn set_borders_with_options(
11377 &self,
11378 params: &DocTablesSetBordersBoundParams,
11379 options: InvokeOptions,
11380 ) -> Result<DocTablesSetBordersResult> {
11381 let params = serde_json::to_value(params)
11382 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11383 let result = self
11384 .invoker
11385 .invoke("doc.tables.setBorders", params, options)
11386 .await?;
11387 serde_json::from_value(result).map_err(|decode| {
11388 let mut error = Error::decode(decode);
11389 error.operation_id = Some("doc.tables.setBorders".to_owned());
11390 error.outcome_unknown = true;
11391 error
11392 })
11393 }
11394
11395 pub async fn set_cell_padding(
11396 &self,
11397 params: &DocTablesSetCellPaddingBoundParams,
11398 ) -> Result<DocTablesSetCellPaddingResult> {
11399 self.set_cell_padding_with_options(params, InvokeOptions::default())
11400 .await
11401 }
11402 pub async fn set_cell_padding_with_options(
11403 &self,
11404 params: &DocTablesSetCellPaddingBoundParams,
11405 options: InvokeOptions,
11406 ) -> Result<DocTablesSetCellPaddingResult> {
11407 let params = serde_json::to_value(params)
11408 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11409 let result = self
11410 .invoker
11411 .invoke("doc.tables.setCellPadding", params, options)
11412 .await?;
11413 serde_json::from_value(result).map_err(|decode| {
11414 let mut error = Error::decode(decode);
11415 error.operation_id = Some("doc.tables.setCellPadding".to_owned());
11416 error.outcome_unknown = true;
11417 error
11418 })
11419 }
11420
11421 pub async fn set_cell_properties(
11422 &self,
11423 params: &DocTablesSetCellPropertiesBoundParams,
11424 ) -> Result<DocTablesSetCellPropertiesResult> {
11425 self.set_cell_properties_with_options(params, InvokeOptions::default())
11426 .await
11427 }
11428 pub async fn set_cell_properties_with_options(
11429 &self,
11430 params: &DocTablesSetCellPropertiesBoundParams,
11431 options: InvokeOptions,
11432 ) -> Result<DocTablesSetCellPropertiesResult> {
11433 let params = serde_json::to_value(params)
11434 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11435 let result = self
11436 .invoker
11437 .invoke("doc.tables.setCellProperties", params, options)
11438 .await?;
11439 serde_json::from_value(result).map_err(|decode| {
11440 let mut error = Error::decode(decode);
11441 error.operation_id = Some("doc.tables.setCellProperties".to_owned());
11442 error.outcome_unknown = true;
11443 error
11444 })
11445 }
11446
11447 pub async fn set_cell_spacing(
11448 &self,
11449 params: &DocTablesSetCellSpacingBoundParams,
11450 ) -> Result<DocTablesSetCellSpacingResult> {
11451 self.set_cell_spacing_with_options(params, InvokeOptions::default())
11452 .await
11453 }
11454 pub async fn set_cell_spacing_with_options(
11455 &self,
11456 params: &DocTablesSetCellSpacingBoundParams,
11457 options: InvokeOptions,
11458 ) -> Result<DocTablesSetCellSpacingResult> {
11459 let params = serde_json::to_value(params)
11460 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11461 let result = self
11462 .invoker
11463 .invoke("doc.tables.setCellSpacing", params, options)
11464 .await?;
11465 serde_json::from_value(result).map_err(|decode| {
11466 let mut error = Error::decode(decode);
11467 error.operation_id = Some("doc.tables.setCellSpacing".to_owned());
11468 error.outcome_unknown = true;
11469 error
11470 })
11471 }
11472
11473 pub async fn set_cell_text(
11474 &self,
11475 params: &DocTablesSetCellTextBoundParams,
11476 ) -> Result<DocTablesSetCellTextResult> {
11477 self.set_cell_text_with_options(params, InvokeOptions::default())
11478 .await
11479 }
11480 pub async fn set_cell_text_with_options(
11481 &self,
11482 params: &DocTablesSetCellTextBoundParams,
11483 options: InvokeOptions,
11484 ) -> Result<DocTablesSetCellTextResult> {
11485 let params = serde_json::to_value(params)
11486 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11487 let result = self
11488 .invoker
11489 .invoke("doc.tables.setCellText", params, options)
11490 .await?;
11491 serde_json::from_value(result).map_err(|decode| {
11492 let mut error = Error::decode(decode);
11493 error.operation_id = Some("doc.tables.setCellText".to_owned());
11494 error.outcome_unknown = true;
11495 error
11496 })
11497 }
11498
11499 pub async fn set_column_width(
11500 &self,
11501 params: &DocTablesSetColumnWidthBoundParams,
11502 ) -> Result<DocTablesSetColumnWidthResult> {
11503 self.set_column_width_with_options(params, InvokeOptions::default())
11504 .await
11505 }
11506 pub async fn set_column_width_with_options(
11507 &self,
11508 params: &DocTablesSetColumnWidthBoundParams,
11509 options: InvokeOptions,
11510 ) -> Result<DocTablesSetColumnWidthResult> {
11511 let params = serde_json::to_value(params)
11512 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11513 let result = self
11514 .invoker
11515 .invoke("doc.tables.setColumnWidth", params, options)
11516 .await?;
11517 serde_json::from_value(result).map_err(|decode| {
11518 let mut error = Error::decode(decode);
11519 error.operation_id = Some("doc.tables.setColumnWidth".to_owned());
11520 error.outcome_unknown = true;
11521 error
11522 })
11523 }
11524
11525 pub async fn set_default_style(
11526 &self,
11527 params: &DocTablesSetDefaultStyleBoundParams,
11528 ) -> Result<DocTablesSetDefaultStyleResult> {
11529 self.set_default_style_with_options(params, InvokeOptions::default())
11530 .await
11531 }
11532 pub async fn set_default_style_with_options(
11533 &self,
11534 params: &DocTablesSetDefaultStyleBoundParams,
11535 options: InvokeOptions,
11536 ) -> Result<DocTablesSetDefaultStyleResult> {
11537 let params = serde_json::to_value(params)
11538 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11539 let result = self
11540 .invoker
11541 .invoke("doc.tables.setDefaultStyle", params, options)
11542 .await?;
11543 serde_json::from_value(result).map_err(|decode| {
11544 let mut error = Error::decode(decode);
11545 error.operation_id = Some("doc.tables.setDefaultStyle".to_owned());
11546 error.outcome_unknown = true;
11547 error
11548 })
11549 }
11550
11551 pub async fn set_layout(
11552 &self,
11553 params: &DocTablesSetLayoutBoundParams,
11554 ) -> Result<DocTablesSetLayoutResult> {
11555 self.set_layout_with_options(params, InvokeOptions::default())
11556 .await
11557 }
11558 pub async fn set_layout_with_options(
11559 &self,
11560 params: &DocTablesSetLayoutBoundParams,
11561 options: InvokeOptions,
11562 ) -> Result<DocTablesSetLayoutResult> {
11563 let params = serde_json::to_value(params)
11564 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11565 let result = self
11566 .invoker
11567 .invoke("doc.tables.setLayout", params, options)
11568 .await?;
11569 serde_json::from_value(result).map_err(|decode| {
11570 let mut error = Error::decode(decode);
11571 error.operation_id = Some("doc.tables.setLayout".to_owned());
11572 error.outcome_unknown = true;
11573 error
11574 })
11575 }
11576
11577 pub async fn set_row_height(
11578 &self,
11579 params: &DocTablesSetRowHeightBoundParams,
11580 ) -> Result<DocTablesSetRowHeightResult> {
11581 self.set_row_height_with_options(params, InvokeOptions::default())
11582 .await
11583 }
11584 pub async fn set_row_height_with_options(
11585 &self,
11586 params: &DocTablesSetRowHeightBoundParams,
11587 options: InvokeOptions,
11588 ) -> Result<DocTablesSetRowHeightResult> {
11589 let params = serde_json::to_value(params)
11590 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11591 let result = self
11592 .invoker
11593 .invoke("doc.tables.setRowHeight", params, options)
11594 .await?;
11595 serde_json::from_value(result).map_err(|decode| {
11596 let mut error = Error::decode(decode);
11597 error.operation_id = Some("doc.tables.setRowHeight".to_owned());
11598 error.outcome_unknown = true;
11599 error
11600 })
11601 }
11602
11603 pub async fn set_row_options(
11604 &self,
11605 params: &DocTablesSetRowOptionsBoundParams,
11606 ) -> Result<DocTablesSetRowOptionsResult> {
11607 self.set_row_options_with_options(params, InvokeOptions::default())
11608 .await
11609 }
11610 pub async fn set_row_options_with_options(
11611 &self,
11612 params: &DocTablesSetRowOptionsBoundParams,
11613 options: InvokeOptions,
11614 ) -> Result<DocTablesSetRowOptionsResult> {
11615 let params = serde_json::to_value(params)
11616 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11617 let result = self
11618 .invoker
11619 .invoke("doc.tables.setRowOptions", params, options)
11620 .await?;
11621 serde_json::from_value(result).map_err(|decode| {
11622 let mut error = Error::decode(decode);
11623 error.operation_id = Some("doc.tables.setRowOptions".to_owned());
11624 error.outcome_unknown = true;
11625 error
11626 })
11627 }
11628
11629 pub async fn set_shading(
11630 &self,
11631 params: &DocTablesSetShadingBoundParams,
11632 ) -> Result<DocTablesSetShadingResult> {
11633 self.set_shading_with_options(params, InvokeOptions::default())
11634 .await
11635 }
11636 pub async fn set_shading_with_options(
11637 &self,
11638 params: &DocTablesSetShadingBoundParams,
11639 options: InvokeOptions,
11640 ) -> Result<DocTablesSetShadingResult> {
11641 let params = serde_json::to_value(params)
11642 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11643 let result = self
11644 .invoker
11645 .invoke("doc.tables.setShading", params, options)
11646 .await?;
11647 serde_json::from_value(result).map_err(|decode| {
11648 let mut error = Error::decode(decode);
11649 error.operation_id = Some("doc.tables.setShading".to_owned());
11650 error.outcome_unknown = true;
11651 error
11652 })
11653 }
11654
11655 pub async fn set_style(
11656 &self,
11657 params: &DocTablesSetStyleBoundParams,
11658 ) -> Result<DocTablesSetStyleResult> {
11659 self.set_style_with_options(params, InvokeOptions::default())
11660 .await
11661 }
11662 pub async fn set_style_with_options(
11663 &self,
11664 params: &DocTablesSetStyleBoundParams,
11665 options: InvokeOptions,
11666 ) -> Result<DocTablesSetStyleResult> {
11667 let params = serde_json::to_value(params)
11668 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11669 let result = self
11670 .invoker
11671 .invoke("doc.tables.setStyle", params, options)
11672 .await?;
11673 serde_json::from_value(result).map_err(|decode| {
11674 let mut error = Error::decode(decode);
11675 error.operation_id = Some("doc.tables.setStyle".to_owned());
11676 error.outcome_unknown = true;
11677 error
11678 })
11679 }
11680
11681 pub async fn set_style_option(
11682 &self,
11683 params: &DocTablesSetStyleOptionBoundParams,
11684 ) -> Result<DocTablesSetStyleOptionResult> {
11685 self.set_style_option_with_options(params, InvokeOptions::default())
11686 .await
11687 }
11688 pub async fn set_style_option_with_options(
11689 &self,
11690 params: &DocTablesSetStyleOptionBoundParams,
11691 options: InvokeOptions,
11692 ) -> Result<DocTablesSetStyleOptionResult> {
11693 let params = serde_json::to_value(params)
11694 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11695 let result = self
11696 .invoker
11697 .invoke("doc.tables.setStyleOption", params, options)
11698 .await?;
11699 serde_json::from_value(result).map_err(|decode| {
11700 let mut error = Error::decode(decode);
11701 error.operation_id = Some("doc.tables.setStyleOption".to_owned());
11702 error.outcome_unknown = true;
11703 error
11704 })
11705 }
11706
11707 pub async fn set_table_options(
11708 &self,
11709 params: &DocTablesSetTableOptionsBoundParams,
11710 ) -> Result<DocTablesSetTableOptionsResult> {
11711 self.set_table_options_with_options(params, InvokeOptions::default())
11712 .await
11713 }
11714 pub async fn set_table_options_with_options(
11715 &self,
11716 params: &DocTablesSetTableOptionsBoundParams,
11717 options: InvokeOptions,
11718 ) -> Result<DocTablesSetTableOptionsResult> {
11719 let params = serde_json::to_value(params)
11720 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11721 let result = self
11722 .invoker
11723 .invoke("doc.tables.setTableOptions", params, options)
11724 .await?;
11725 serde_json::from_value(result).map_err(|decode| {
11726 let mut error = Error::decode(decode);
11727 error.operation_id = Some("doc.tables.setTableOptions".to_owned());
11728 error.outcome_unknown = true;
11729 error
11730 })
11731 }
11732
11733 pub async fn set_table_padding(
11734 &self,
11735 params: &DocTablesSetTablePaddingBoundParams,
11736 ) -> Result<DocTablesSetTablePaddingResult> {
11737 self.set_table_padding_with_options(params, InvokeOptions::default())
11738 .await
11739 }
11740 pub async fn set_table_padding_with_options(
11741 &self,
11742 params: &DocTablesSetTablePaddingBoundParams,
11743 options: InvokeOptions,
11744 ) -> Result<DocTablesSetTablePaddingResult> {
11745 let params = serde_json::to_value(params)
11746 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11747 let result = self
11748 .invoker
11749 .invoke("doc.tables.setTablePadding", params, options)
11750 .await?;
11751 serde_json::from_value(result).map_err(|decode| {
11752 let mut error = Error::decode(decode);
11753 error.operation_id = Some("doc.tables.setTablePadding".to_owned());
11754 error.outcome_unknown = true;
11755 error
11756 })
11757 }
11758
11759 pub async fn sort(&self, params: &DocTablesSortBoundParams) -> Result<DocTablesSortResult> {
11760 self.sort_with_options(params, InvokeOptions::default())
11761 .await
11762 }
11763 pub async fn sort_with_options(
11764 &self,
11765 params: &DocTablesSortBoundParams,
11766 options: InvokeOptions,
11767 ) -> Result<DocTablesSortResult> {
11768 let params = serde_json::to_value(params)
11769 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11770 let result = self
11771 .invoker
11772 .invoke("doc.tables.sort", params, options)
11773 .await?;
11774 serde_json::from_value(result).map_err(|decode| {
11775 let mut error = Error::decode(decode);
11776 error.operation_id = Some("doc.tables.sort".to_owned());
11777 error.outcome_unknown = true;
11778 error
11779 })
11780 }
11781
11782 pub async fn split(&self, params: &DocTablesSplitBoundParams) -> Result<DocTablesSplitResult> {
11783 self.split_with_options(params, InvokeOptions::default())
11784 .await
11785 }
11786 pub async fn split_with_options(
11787 &self,
11788 params: &DocTablesSplitBoundParams,
11789 options: InvokeOptions,
11790 ) -> Result<DocTablesSplitResult> {
11791 let params = serde_json::to_value(params)
11792 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11793 let result = self
11794 .invoker
11795 .invoke("doc.tables.split", params, options)
11796 .await?;
11797 serde_json::from_value(result).map_err(|decode| {
11798 let mut error = Error::decode(decode);
11799 error.operation_id = Some("doc.tables.split".to_owned());
11800 error.outcome_unknown = true;
11801 error
11802 })
11803 }
11804
11805 pub async fn split_cell(
11806 &self,
11807 params: &DocTablesSplitCellBoundParams,
11808 ) -> Result<DocTablesSplitCellResult> {
11809 self.split_cell_with_options(params, InvokeOptions::default())
11810 .await
11811 }
11812 pub async fn split_cell_with_options(
11813 &self,
11814 params: &DocTablesSplitCellBoundParams,
11815 options: InvokeOptions,
11816 ) -> Result<DocTablesSplitCellResult> {
11817 let params = serde_json::to_value(params)
11818 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11819 let result = self
11820 .invoker
11821 .invoke("doc.tables.splitCell", params, options)
11822 .await?;
11823 serde_json::from_value(result).map_err(|decode| {
11824 let mut error = Error::decode(decode);
11825 error.operation_id = Some("doc.tables.splitCell".to_owned());
11826 error.outcome_unknown = true;
11827 error
11828 })
11829 }
11830
11831 pub async fn unmerge_cells(
11832 &self,
11833 params: &DocTablesUnmergeCellsBoundParams,
11834 ) -> Result<DocTablesUnmergeCellsResult> {
11835 self.unmerge_cells_with_options(params, InvokeOptions::default())
11836 .await
11837 }
11838 pub async fn unmerge_cells_with_options(
11839 &self,
11840 params: &DocTablesUnmergeCellsBoundParams,
11841 options: InvokeOptions,
11842 ) -> Result<DocTablesUnmergeCellsResult> {
11843 let params = serde_json::to_value(params)
11844 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11845 let result = self
11846 .invoker
11847 .invoke("doc.tables.unmergeCells", params, options)
11848 .await?;
11849 serde_json::from_value(result).map_err(|decode| {
11850 let mut error = Error::decode(decode);
11851 error.operation_id = Some("doc.tables.unmergeCells".to_owned());
11852 error.outcome_unknown = true;
11853 error
11854 })
11855 }
11856}
11857
11858pub struct DocApiTemplates<'a, I: Invoker> {
11859 invoker: &'a I,
11860}
11861impl<'a, I: Invoker> DocApiTemplates<'a, I> {
11862 pub fn new(invoker: &'a I) -> Self {
11863 Self { invoker }
11864 }
11865
11866 pub async fn apply(
11867 &self,
11868 params: &DocTemplatesApplyBoundParams,
11869 ) -> Result<DocTemplatesApplyResult> {
11870 self.apply_with_options(params, InvokeOptions::default())
11871 .await
11872 }
11873 pub async fn apply_with_options(
11874 &self,
11875 params: &DocTemplatesApplyBoundParams,
11876 options: InvokeOptions,
11877 ) -> Result<DocTemplatesApplyResult> {
11878 let params = serde_json::to_value(params)
11879 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11880 let result = self
11881 .invoker
11882 .invoke("doc.templates.apply", params, options)
11883 .await?;
11884 serde_json::from_value(result).map_err(|decode| {
11885 let mut error = Error::decode(decode);
11886 error.operation_id = Some("doc.templates.apply".to_owned());
11887 error.outcome_unknown = true;
11888 error
11889 })
11890 }
11891}
11892
11893pub struct DocApiToc<'a, I: Invoker> {
11894 invoker: &'a I,
11895}
11896impl<'a, I: Invoker> DocApiToc<'a, I> {
11897 pub fn new(invoker: &'a I) -> Self {
11898 Self { invoker }
11899 }
11900
11901 pub async fn configure(
11902 &self,
11903 params: &DocTocConfigureBoundParams,
11904 ) -> Result<DocTocConfigureResult> {
11905 self.configure_with_options(params, InvokeOptions::default())
11906 .await
11907 }
11908 pub async fn configure_with_options(
11909 &self,
11910 params: &DocTocConfigureBoundParams,
11911 options: InvokeOptions,
11912 ) -> Result<DocTocConfigureResult> {
11913 let params = serde_json::to_value(params)
11914 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11915 let result = self
11916 .invoker
11917 .invoke("doc.toc.configure", params, options)
11918 .await?;
11919 serde_json::from_value(result).map_err(|decode| {
11920 let mut error = Error::decode(decode);
11921 error.operation_id = Some("doc.toc.configure".to_owned());
11922 error.outcome_unknown = true;
11923 error
11924 })
11925 }
11926
11927 pub async fn edit_entry(
11928 &self,
11929 params: &DocTocEditEntryBoundParams,
11930 ) -> Result<DocTocEditEntryResult> {
11931 self.edit_entry_with_options(params, InvokeOptions::default())
11932 .await
11933 }
11934 pub async fn edit_entry_with_options(
11935 &self,
11936 params: &DocTocEditEntryBoundParams,
11937 options: InvokeOptions,
11938 ) -> Result<DocTocEditEntryResult> {
11939 let params = serde_json::to_value(params)
11940 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11941 let result = self
11942 .invoker
11943 .invoke("doc.toc.editEntry", params, options)
11944 .await?;
11945 serde_json::from_value(result).map_err(|decode| {
11946 let mut error = Error::decode(decode);
11947 error.operation_id = Some("doc.toc.editEntry".to_owned());
11948 error.outcome_unknown = true;
11949 error
11950 })
11951 }
11952
11953 pub async fn get(&self, params: &DocTocGetBoundParams) -> Result<DocTocGetResult> {
11954 self.get_with_options(params, InvokeOptions::default())
11955 .await
11956 }
11957 pub async fn get_with_options(
11958 &self,
11959 params: &DocTocGetBoundParams,
11960 options: InvokeOptions,
11961 ) -> Result<DocTocGetResult> {
11962 let params = serde_json::to_value(params)
11963 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11964 let result = self.invoker.invoke("doc.toc.get", params, options).await?;
11965 serde_json::from_value(result).map_err(|decode| {
11966 let mut error = Error::decode(decode);
11967 error.operation_id = Some("doc.toc.get".to_owned());
11968 error.outcome_unknown = false;
11969 error
11970 })
11971 }
11972
11973 pub async fn get_entry(
11974 &self,
11975 params: &DocTocGetEntryBoundParams,
11976 ) -> Result<DocTocGetEntryResult> {
11977 self.get_entry_with_options(params, InvokeOptions::default())
11978 .await
11979 }
11980 pub async fn get_entry_with_options(
11981 &self,
11982 params: &DocTocGetEntryBoundParams,
11983 options: InvokeOptions,
11984 ) -> Result<DocTocGetEntryResult> {
11985 let params = serde_json::to_value(params)
11986 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
11987 let result = self
11988 .invoker
11989 .invoke("doc.toc.getEntry", params, options)
11990 .await?;
11991 serde_json::from_value(result).map_err(|decode| {
11992 let mut error = Error::decode(decode);
11993 error.operation_id = Some("doc.toc.getEntry".to_owned());
11994 error.outcome_unknown = false;
11995 error
11996 })
11997 }
11998
11999 pub async fn list(&self, params: &DocTocListBoundParams) -> Result<DocTocListResult> {
12000 self.list_with_options(params, InvokeOptions::default())
12001 .await
12002 }
12003 pub async fn list_with_options(
12004 &self,
12005 params: &DocTocListBoundParams,
12006 options: InvokeOptions,
12007 ) -> Result<DocTocListResult> {
12008 let params = serde_json::to_value(params)
12009 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
12010 let result = self.invoker.invoke("doc.toc.list", params, options).await?;
12011 serde_json::from_value(result).map_err(|decode| {
12012 let mut error = Error::decode(decode);
12013 error.operation_id = Some("doc.toc.list".to_owned());
12014 error.outcome_unknown = false;
12015 error
12016 })
12017 }
12018
12019 pub async fn list_entries(
12020 &self,
12021 params: &DocTocListEntriesBoundParams,
12022 ) -> Result<DocTocListEntriesResult> {
12023 self.list_entries_with_options(params, InvokeOptions::default())
12024 .await
12025 }
12026 pub async fn list_entries_with_options(
12027 &self,
12028 params: &DocTocListEntriesBoundParams,
12029 options: InvokeOptions,
12030 ) -> Result<DocTocListEntriesResult> {
12031 let params = serde_json::to_value(params)
12032 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
12033 let result = self
12034 .invoker
12035 .invoke("doc.toc.listEntries", params, options)
12036 .await?;
12037 serde_json::from_value(result).map_err(|decode| {
12038 let mut error = Error::decode(decode);
12039 error.operation_id = Some("doc.toc.listEntries".to_owned());
12040 error.outcome_unknown = false;
12041 error
12042 })
12043 }
12044
12045 pub async fn mark_entry(
12046 &self,
12047 params: &DocTocMarkEntryBoundParams,
12048 ) -> Result<DocTocMarkEntryResult> {
12049 self.mark_entry_with_options(params, InvokeOptions::default())
12050 .await
12051 }
12052 pub async fn mark_entry_with_options(
12053 &self,
12054 params: &DocTocMarkEntryBoundParams,
12055 options: InvokeOptions,
12056 ) -> Result<DocTocMarkEntryResult> {
12057 let params = serde_json::to_value(params)
12058 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
12059 let result = self
12060 .invoker
12061 .invoke("doc.toc.markEntry", params, options)
12062 .await?;
12063 serde_json::from_value(result).map_err(|decode| {
12064 let mut error = Error::decode(decode);
12065 error.operation_id = Some("doc.toc.markEntry".to_owned());
12066 error.outcome_unknown = true;
12067 error
12068 })
12069 }
12070
12071 pub async fn remove(&self, params: &DocTocRemoveBoundParams) -> Result<DocTocRemoveResult> {
12072 self.remove_with_options(params, InvokeOptions::default())
12073 .await
12074 }
12075 pub async fn remove_with_options(
12076 &self,
12077 params: &DocTocRemoveBoundParams,
12078 options: InvokeOptions,
12079 ) -> Result<DocTocRemoveResult> {
12080 let params = serde_json::to_value(params)
12081 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
12082 let result = self
12083 .invoker
12084 .invoke("doc.toc.remove", params, options)
12085 .await?;
12086 serde_json::from_value(result).map_err(|decode| {
12087 let mut error = Error::decode(decode);
12088 error.operation_id = Some("doc.toc.remove".to_owned());
12089 error.outcome_unknown = true;
12090 error
12091 })
12092 }
12093
12094 pub async fn unmark_entry(
12095 &self,
12096 params: &DocTocUnmarkEntryBoundParams,
12097 ) -> Result<DocTocUnmarkEntryResult> {
12098 self.unmark_entry_with_options(params, InvokeOptions::default())
12099 .await
12100 }
12101 pub async fn unmark_entry_with_options(
12102 &self,
12103 params: &DocTocUnmarkEntryBoundParams,
12104 options: InvokeOptions,
12105 ) -> Result<DocTocUnmarkEntryResult> {
12106 let params = serde_json::to_value(params)
12107 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
12108 let result = self
12109 .invoker
12110 .invoke("doc.toc.unmarkEntry", params, options)
12111 .await?;
12112 serde_json::from_value(result).map_err(|decode| {
12113 let mut error = Error::decode(decode);
12114 error.operation_id = Some("doc.toc.unmarkEntry".to_owned());
12115 error.outcome_unknown = true;
12116 error
12117 })
12118 }
12119
12120 pub async fn update(&self, params: &DocTocUpdateBoundParams) -> Result<DocTocUpdateResult> {
12121 self.update_with_options(params, InvokeOptions::default())
12122 .await
12123 }
12124 pub async fn update_with_options(
12125 &self,
12126 params: &DocTocUpdateBoundParams,
12127 options: InvokeOptions,
12128 ) -> Result<DocTocUpdateResult> {
12129 let params = serde_json::to_value(params)
12130 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
12131 let result = self
12132 .invoker
12133 .invoke("doc.toc.update", params, options)
12134 .await?;
12135 serde_json::from_value(result).map_err(|decode| {
12136 let mut error = Error::decode(decode);
12137 error.operation_id = Some("doc.toc.update".to_owned());
12138 error.outcome_unknown = true;
12139 error
12140 })
12141 }
12142}
12143
12144pub struct DocApiTrackChanges<'a, I: Invoker> {
12145 invoker: &'a I,
12146}
12147impl<'a, I: Invoker> DocApiTrackChanges<'a, I> {
12148 pub fn new(invoker: &'a I) -> Self {
12149 Self { invoker }
12150 }
12151
12152 pub async fn decide(
12153 &self,
12154 params: &DocTrackChangesDecideBoundParams,
12155 ) -> Result<DocTrackChangesDecideResult> {
12156 self.decide_with_options(params, InvokeOptions::default())
12157 .await
12158 }
12159 pub async fn decide_with_options(
12160 &self,
12161 params: &DocTrackChangesDecideBoundParams,
12162 options: InvokeOptions,
12163 ) -> Result<DocTrackChangesDecideResult> {
12164 let params = serde_json::to_value(params)
12165 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
12166 let result = self
12167 .invoker
12168 .invoke("doc.trackChanges.decide", params, options)
12169 .await?;
12170 serde_json::from_value(result).map_err(|decode| {
12171 let mut error = Error::decode(decode);
12172 error.operation_id = Some("doc.trackChanges.decide".to_owned());
12173 error.outcome_unknown = true;
12174 error
12175 })
12176 }
12177
12178 pub async fn get(
12179 &self,
12180 params: &DocTrackChangesGetBoundParams,
12181 ) -> Result<DocTrackChangesGetResult> {
12182 self.get_with_options(params, InvokeOptions::default())
12183 .await
12184 }
12185 pub async fn get_with_options(
12186 &self,
12187 params: &DocTrackChangesGetBoundParams,
12188 options: InvokeOptions,
12189 ) -> Result<DocTrackChangesGetResult> {
12190 let params = serde_json::to_value(params)
12191 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
12192 let result = self
12193 .invoker
12194 .invoke("doc.trackChanges.get", params, options)
12195 .await?;
12196 serde_json::from_value(result).map_err(|decode| {
12197 let mut error = Error::decode(decode);
12198 error.operation_id = Some("doc.trackChanges.get".to_owned());
12199 error.outcome_unknown = false;
12200 error
12201 })
12202 }
12203
12204 pub async fn list(
12205 &self,
12206 params: &DocTrackChangesListBoundParams,
12207 ) -> Result<DocTrackChangesListResult> {
12208 self.list_with_options(params, InvokeOptions::default())
12209 .await
12210 }
12211 pub async fn list_with_options(
12212 &self,
12213 params: &DocTrackChangesListBoundParams,
12214 options: InvokeOptions,
12215 ) -> Result<DocTrackChangesListResult> {
12216 let params = serde_json::to_value(params)
12217 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
12218 let result = self
12219 .invoker
12220 .invoke("doc.trackChanges.list", params, options)
12221 .await?;
12222 serde_json::from_value(result).map_err(|decode| {
12223 let mut error = Error::decode(decode);
12224 error.operation_id = Some("doc.trackChanges.list".to_owned());
12225 error.outcome_unknown = false;
12226 error
12227 })
12228 }
12229}
12230
12231pub struct DocApiWatermarks<'a, I: Invoker> {
12232 invoker: &'a I,
12233}
12234impl<'a, I: Invoker> DocApiWatermarks<'a, I> {
12235 pub fn new(invoker: &'a I) -> Self {
12236 Self { invoker }
12237 }
12238
12239 pub async fn apply(
12240 &self,
12241 params: &DocWatermarksApplyBoundParams,
12242 ) -> Result<DocWatermarksApplyResult> {
12243 self.apply_with_options(params, InvokeOptions::default())
12244 .await
12245 }
12246 pub async fn apply_with_options(
12247 &self,
12248 params: &DocWatermarksApplyBoundParams,
12249 options: InvokeOptions,
12250 ) -> Result<DocWatermarksApplyResult> {
12251 let params = serde_json::to_value(params)
12252 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
12253 let result = self
12254 .invoker
12255 .invoke("doc.watermarks.apply", params, options)
12256 .await?;
12257 serde_json::from_value(result).map_err(|decode| {
12258 let mut error = Error::decode(decode);
12259 error.operation_id = Some("doc.watermarks.apply".to_owned());
12260 error.outcome_unknown = true;
12261 error
12262 })
12263 }
12264
12265 pub async fn insert(
12266 &self,
12267 params: &DocWatermarksInsertBoundParams,
12268 ) -> Result<DocWatermarksInsertResult> {
12269 self.insert_with_options(params, InvokeOptions::default())
12270 .await
12271 }
12272 pub async fn insert_with_options(
12273 &self,
12274 params: &DocWatermarksInsertBoundParams,
12275 options: InvokeOptions,
12276 ) -> Result<DocWatermarksInsertResult> {
12277 let params = serde_json::to_value(params)
12278 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
12279 let result = self
12280 .invoker
12281 .invoke("doc.watermarks.insert", params, options)
12282 .await?;
12283 serde_json::from_value(result).map_err(|decode| {
12284 let mut error = Error::decode(decode);
12285 error.operation_id = Some("doc.watermarks.insert".to_owned());
12286 error.outcome_unknown = true;
12287 error
12288 })
12289 }
12290
12291 pub async fn list(
12292 &self,
12293 params: &DocWatermarksListBoundParams,
12294 ) -> Result<DocWatermarksListResult> {
12295 self.list_with_options(params, InvokeOptions::default())
12296 .await
12297 }
12298 pub async fn list_with_options(
12299 &self,
12300 params: &DocWatermarksListBoundParams,
12301 options: InvokeOptions,
12302 ) -> Result<DocWatermarksListResult> {
12303 let params = serde_json::to_value(params)
12304 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
12305 let result = self
12306 .invoker
12307 .invoke("doc.watermarks.list", params, options)
12308 .await?;
12309 serde_json::from_value(result).map_err(|decode| {
12310 let mut error = Error::decode(decode);
12311 error.operation_id = Some("doc.watermarks.list".to_owned());
12312 error.outcome_unknown = false;
12313 error
12314 })
12315 }
12316
12317 pub async fn remove(
12318 &self,
12319 params: &DocWatermarksRemoveBoundParams,
12320 ) -> Result<DocWatermarksRemoveResult> {
12321 self.remove_with_options(params, InvokeOptions::default())
12322 .await
12323 }
12324 pub async fn remove_with_options(
12325 &self,
12326 params: &DocWatermarksRemoveBoundParams,
12327 options: InvokeOptions,
12328 ) -> Result<DocWatermarksRemoveResult> {
12329 let params = serde_json::to_value(params)
12330 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
12331 let result = self
12332 .invoker
12333 .invoke("doc.watermarks.remove", params, options)
12334 .await?;
12335 serde_json::from_value(result).map_err(|decode| {
12336 let mut error = Error::decode(decode);
12337 error.operation_id = Some("doc.watermarks.remove".to_owned());
12338 error.outcome_unknown = true;
12339 error
12340 })
12341 }
12342
12343 pub async fn replace(
12344 &self,
12345 params: &DocWatermarksReplaceBoundParams,
12346 ) -> Result<DocWatermarksReplaceResult> {
12347 self.replace_with_options(params, InvokeOptions::default())
12348 .await
12349 }
12350 pub async fn replace_with_options(
12351 &self,
12352 params: &DocWatermarksReplaceBoundParams,
12353 options: InvokeOptions,
12354 ) -> Result<DocWatermarksReplaceResult> {
12355 let params = serde_json::to_value(params)
12356 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
12357 let result = self
12358 .invoker
12359 .invoke("doc.watermarks.replace", params, options)
12360 .await?;
12361 serde_json::from_value(result).map_err(|decode| {
12362 let mut error = Error::decode(decode);
12363 error.operation_id = Some("doc.watermarks.replace".to_owned());
12364 error.outcome_unknown = true;
12365 error
12366 })
12367 }
12368}
12369
12370pub(crate) struct ClientApi<'a, I: Invoker> {
12371 invoker: &'a I,
12372}
12373impl<'a, I: Invoker> ClientApi<'a, I> {
12374 pub(crate) fn new(invoker: &'a I) -> Self {
12375 Self { invoker }
12376 }
12377
12378 pub(crate) async fn describe(&self, params: &DocDescribeParams) -> Result<DocDescribeResult> {
12379 self.describe_with_options(params, InvokeOptions::default())
12380 .await
12381 }
12382 pub(crate) async fn describe_with_options(
12383 &self,
12384 params: &DocDescribeParams,
12385 options: InvokeOptions,
12386 ) -> Result<DocDescribeResult> {
12387 let params = serde_json::to_value(params)
12388 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
12389 let result = self.invoker.invoke("doc.describe", params, options).await?;
12390 serde_json::from_value(result).map_err(|decode| {
12391 let mut error = Error::decode(decode);
12392 error.operation_id = Some("doc.describe".to_owned());
12393 error.outcome_unknown = false;
12394 error
12395 })
12396 }
12397
12398 pub(crate) async fn describe_command(
12399 &self,
12400 params: &DocDescribeCommandParams,
12401 ) -> Result<DocDescribeCommandResult> {
12402 self.describe_command_with_options(params, InvokeOptions::default())
12403 .await
12404 }
12405 pub(crate) async fn describe_command_with_options(
12406 &self,
12407 params: &DocDescribeCommandParams,
12408 options: InvokeOptions,
12409 ) -> Result<DocDescribeCommandResult> {
12410 let params = serde_json::to_value(params)
12411 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
12412 let result = self
12413 .invoker
12414 .invoke("doc.describeCommand", params, options)
12415 .await?;
12416 serde_json::from_value(result).map_err(|decode| {
12417 let mut error = Error::decode(decode);
12418 error.operation_id = Some("doc.describeCommand".to_owned());
12419 error.outcome_unknown = false;
12420 error
12421 })
12422 }
12423
12424 pub(crate) async fn open(&self, params: &DocOpenParams) -> Result<DocOpenResult> {
12425 self.open_with_options(params, InvokeOptions::default())
12426 .await
12427 }
12428 pub(crate) async fn open_with_options(
12429 &self,
12430 params: &DocOpenParams,
12431 options: InvokeOptions,
12432 ) -> Result<DocOpenResult> {
12433 let params = serde_json::to_value(params)
12434 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
12435 let result = self.invoker.invoke("doc.open", params, options).await?;
12436 serde_json::from_value(result).map_err(|decode| {
12437 let mut error = Error::decode(decode);
12438 error.operation_id = Some("doc.open".to_owned());
12439 error.outcome_unknown = true;
12440 error
12441 })
12442 }
12443}
12444
12445pub(crate) struct InternalApi<'a, I: Invoker> {
12446 invoker: &'a I,
12447}
12448impl<'a, I: Invoker> InternalApi<'a, I> {
12449 pub(crate) fn new(invoker: &'a I) -> Self {
12450 Self { invoker }
12451 }
12452 pub(crate) fn session(&self) -> InternalApiSession<'a, I> {
12453 InternalApiSession::new(self.invoker)
12454 }
12455
12456 pub(crate) async fn discover(&self, params: &DocDiscoverParams) -> Result<DocDiscoverResult> {
12457 self.discover_with_options(params, InvokeOptions::default())
12458 .await
12459 }
12460 pub(crate) async fn discover_with_options(
12461 &self,
12462 params: &DocDiscoverParams,
12463 options: InvokeOptions,
12464 ) -> Result<DocDiscoverResult> {
12465 let params = serde_json::to_value(params)
12466 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
12467 let result = self.invoker.invoke("doc.discover", params, options).await?;
12468 serde_json::from_value(result).map_err(|decode| {
12469 let mut error = Error::decode(decode);
12470 error.operation_id = Some("doc.discover".to_owned());
12471 error.outcome_unknown = false;
12472 error
12473 })
12474 }
12475
12476 pub(crate) async fn status(&self, params: &DocStatusParams) -> Result<DocStatusResult> {
12477 self.status_with_options(params, InvokeOptions::default())
12478 .await
12479 }
12480 pub(crate) async fn status_with_options(
12481 &self,
12482 params: &DocStatusParams,
12483 options: InvokeOptions,
12484 ) -> Result<DocStatusResult> {
12485 let params = serde_json::to_value(params)
12486 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
12487 let result = self.invoker.invoke("doc.status", params, options).await?;
12488 serde_json::from_value(result).map_err(|decode| {
12489 let mut error = Error::decode(decode);
12490 error.operation_id = Some("doc.status".to_owned());
12491 error.outcome_unknown = false;
12492 error
12493 })
12494 }
12495}
12496
12497pub(crate) struct InternalApiSession<'a, I: Invoker> {
12498 invoker: &'a I,
12499}
12500impl<'a, I: Invoker> InternalApiSession<'a, I> {
12501 pub(crate) fn new(invoker: &'a I) -> Self {
12502 Self { invoker }
12503 }
12504
12505 pub(crate) async fn close(
12506 &self,
12507 params: &DocSessionCloseParams,
12508 ) -> Result<DocSessionCloseResult> {
12509 self.close_with_options(params, InvokeOptions::default())
12510 .await
12511 }
12512 pub(crate) async fn close_with_options(
12513 &self,
12514 params: &DocSessionCloseParams,
12515 options: InvokeOptions,
12516 ) -> Result<DocSessionCloseResult> {
12517 let params = serde_json::to_value(params)
12518 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
12519 let result = self
12520 .invoker
12521 .invoke("doc.session.close", params, options)
12522 .await?;
12523 serde_json::from_value(result).map_err(|decode| {
12524 let mut error = Error::decode(decode);
12525 error.operation_id = Some("doc.session.close".to_owned());
12526 error.outcome_unknown = true;
12527 error
12528 })
12529 }
12530
12531 pub(crate) async fn list(&self, params: &DocSessionListParams) -> Result<DocSessionListResult> {
12532 self.list_with_options(params, InvokeOptions::default())
12533 .await
12534 }
12535 pub(crate) async fn list_with_options(
12536 &self,
12537 params: &DocSessionListParams,
12538 options: InvokeOptions,
12539 ) -> Result<DocSessionListResult> {
12540 let params = serde_json::to_value(params)
12541 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
12542 let result = self
12543 .invoker
12544 .invoke("doc.session.list", params, options)
12545 .await?;
12546 serde_json::from_value(result).map_err(|decode| {
12547 let mut error = Error::decode(decode);
12548 error.operation_id = Some("doc.session.list".to_owned());
12549 error.outcome_unknown = false;
12550 error
12551 })
12552 }
12553
12554 pub(crate) async fn save(&self, params: &DocSessionSaveParams) -> Result<DocSessionSaveResult> {
12555 self.save_with_options(params, InvokeOptions::default())
12556 .await
12557 }
12558 pub(crate) async fn save_with_options(
12559 &self,
12560 params: &DocSessionSaveParams,
12561 options: InvokeOptions,
12562 ) -> Result<DocSessionSaveResult> {
12563 let params = serde_json::to_value(params)
12564 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
12565 let result = self
12566 .invoker
12567 .invoke("doc.session.save", params, options)
12568 .await?;
12569 serde_json::from_value(result).map_err(|decode| {
12570 let mut error = Error::decode(decode);
12571 error.operation_id = Some("doc.session.save".to_owned());
12572 error.outcome_unknown = true;
12573 error
12574 })
12575 }
12576
12577 pub(crate) async fn set_default(
12578 &self,
12579 params: &DocSessionSetDefaultParams,
12580 ) -> Result<DocSessionSetDefaultResult> {
12581 self.set_default_with_options(params, InvokeOptions::default())
12582 .await
12583 }
12584 pub(crate) async fn set_default_with_options(
12585 &self,
12586 params: &DocSessionSetDefaultParams,
12587 options: InvokeOptions,
12588 ) -> Result<DocSessionSetDefaultResult> {
12589 let params = serde_json::to_value(params)
12590 .map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
12591 let result = self
12592 .invoker
12593 .invoke("doc.session.setDefault", params, options)
12594 .await?;
12595 serde_json::from_value(result).map_err(|decode| {
12596 let mut error = Error::decode(decode);
12597 error.operation_id = Some("doc.session.setDefault".to_owned());
12598 error.outcome_unknown = true;
12599 error
12600 })
12601 }
12602}
12603
12604#[cfg(any(test, feature = "conformance"))]
12605pub(crate) async fn exercise_callables<I: Invoker>(invoker: &I) {
12606 {
12607 let params:DocAuthoritiesConfigureBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"tableOfAuthorities\",\"nodeId\":\"\"},\"patch\":{}}").expect("generated inhabited parameter fixture");
12608 let _ = DocApi::new(invoker).authorities().configure(¶ms).await;
12609 }
12610
12611 {
12612 let params:DocAuthoritiesEntriesGetBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"inline\",\"nodeType\":\"authorityEntry\",\"anchor\":{\"start\":{\"blockId\":\"\",\"offset\":0},\"end\":{\"blockId\":\"\",\"offset\":0}}}}").expect("generated inhabited parameter fixture");
12613 let _ = DocApi::new(invoker)
12614 .authorities()
12615 .entries()
12616 .get(¶ms)
12617 .await;
12618 }
12619
12620 {
12621 let params:DocAuthoritiesEntriesInsertBoundParams=serde_json::from_str("{\"at\":{\"kind\":\"text\",\"segments\":[]},\"entry\":{\"longCitation\":\"\",\"category\":\"\"}}").expect("generated inhabited parameter fixture");
12622 let _ = DocApi::new(invoker)
12623 .authorities()
12624 .entries()
12625 .insert(¶ms)
12626 .await;
12627 }
12628
12629 {
12630 let params: DocAuthoritiesEntriesListBoundParams =
12631 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
12632 let _ = DocApi::new(invoker)
12633 .authorities()
12634 .entries()
12635 .list(¶ms)
12636 .await;
12637 }
12638
12639 {
12640 let params:DocAuthoritiesEntriesRemoveBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"inline\",\"nodeType\":\"authorityEntry\",\"anchor\":{\"start\":{\"blockId\":\"\",\"offset\":0},\"end\":{\"blockId\":\"\",\"offset\":0}}}}").expect("generated inhabited parameter fixture");
12641 let _ = DocApi::new(invoker)
12642 .authorities()
12643 .entries()
12644 .remove(¶ms)
12645 .await;
12646 }
12647
12648 {
12649 let params:DocAuthoritiesEntriesUpdateBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"inline\",\"nodeType\":\"authorityEntry\",\"anchor\":{\"start\":{\"blockId\":\"\",\"offset\":0},\"end\":{\"blockId\":\"\",\"offset\":0}}},\"patch\":{}}").expect("generated inhabited parameter fixture");
12650 let _ = DocApi::new(invoker)
12651 .authorities()
12652 .entries()
12653 .update(¶ms)
12654 .await;
12655 }
12656
12657 {
12658 let params: DocAuthoritiesGetBoundParams = serde_json::from_str(
12659 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"tableOfAuthorities\",\"nodeId\":\"\"}}",
12660 )
12661 .expect("generated inhabited parameter fixture");
12662 let _ = DocApi::new(invoker).authorities().get(¶ms).await;
12663 }
12664
12665 {
12666 let params: DocAuthoritiesInsertBoundParams =
12667 serde_json::from_str("{\"at\":{\"kind\":\"documentStart\"}}")
12668 .expect("generated inhabited parameter fixture");
12669 let _ = DocApi::new(invoker).authorities().insert(¶ms).await;
12670 }
12671
12672 {
12673 let params: DocAuthoritiesListBoundParams =
12674 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
12675 let _ = DocApi::new(invoker).authorities().list(¶ms).await;
12676 }
12677
12678 {
12679 let params: DocAuthoritiesRebuildBoundParams = serde_json::from_str(
12680 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"tableOfAuthorities\",\"nodeId\":\"\"}}",
12681 )
12682 .expect("generated inhabited parameter fixture");
12683 let _ = DocApi::new(invoker).authorities().rebuild(¶ms).await;
12684 }
12685
12686 {
12687 let params: DocAuthoritiesRemoveBoundParams = serde_json::from_str(
12688 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"tableOfAuthorities\",\"nodeId\":\"\"}}",
12689 )
12690 .expect("generated inhabited parameter fixture");
12691 let _ = DocApi::new(invoker).authorities().remove(¶ms).await;
12692 }
12693
12694 {
12695 let params: DocBlocksDeleteBoundParams =
12696 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
12697 let _ = DocApi::new(invoker).blocks().delete(¶ms).await;
12698 }
12699
12700 {
12701 let params: DocBlocksDeleteRangeBoundParams =
12702 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
12703 let _ = DocApi::new(invoker).blocks().delete_range(¶ms).await;
12704 }
12705
12706 {
12707 let params: DocBlocksFindTextBoundParams =
12708 serde_json::from_str("{\"text\":\"\"}").expect("generated inhabited parameter fixture");
12709 let _ = DocApi::new(invoker).blocks().find_text(¶ms).await;
12710 }
12711
12712 {
12713 let params: DocBlocksListBoundParams =
12714 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
12715 let _ = DocApi::new(invoker).blocks().list(¶ms).await;
12716 }
12717
12718 {
12719 let params:DocBlocksMergeBoundParams=serde_json::from_str("{\"first\":{\"kind\":\"block\",\"nodeType\":\"paragraph\",\"nodeId\":\"\"},\"second\":{\"kind\":\"block\",\"nodeType\":\"paragraph\",\"nodeId\":\"\"}}").expect("generated inhabited parameter fixture");
12720 let _ = DocApi::new(invoker).blocks().merge(¶ms).await;
12721 }
12722
12723 {
12724 let params:DocBlocksMoveBoundParams=serde_json::from_str("{\"source\":{\"kind\":\"block\",\"nodeType\":\"paragraph\",\"nodeId\":\"\"},\"destination\":{\"kind\":\"block\",\"nodeType\":\"paragraph\",\"nodeId\":\"\"},\"placement\":\"before\"}").expect("generated inhabited parameter fixture");
12725 let _ = DocApi::new(invoker).blocks().move_(¶ms).await;
12726 }
12727
12728 {
12729 let params:DocBlocksSplitBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"paragraph\",\"nodeId\":\"\"},\"offset\":0}").expect("generated inhabited parameter fixture");
12730 let _ = DocApi::new(invoker).blocks().split(¶ms).await;
12731 }
12732
12733 {
12734 let params: DocBookmarksGetBoundParams = serde_json::from_str(
12735 "{\"target\":{\"kind\":\"entity\",\"entityType\":\"bookmark\",\"name\":\"\"}}",
12736 )
12737 .expect("generated inhabited parameter fixture");
12738 let _ = DocApi::new(invoker).bookmarks().get(¶ms).await;
12739 }
12740
12741 {
12742 let params: DocBookmarksInsertBoundParams =
12743 serde_json::from_str("{\"name\":\"\",\"at\":{\"kind\":\"text\",\"segments\":[]}}")
12744 .expect("generated inhabited parameter fixture");
12745 let _ = DocApi::new(invoker).bookmarks().insert(¶ms).await;
12746 }
12747
12748 {
12749 let params: DocBookmarksListBoundParams =
12750 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
12751 let _ = DocApi::new(invoker).bookmarks().list(¶ms).await;
12752 }
12753
12754 {
12755 let params: DocBookmarksRemoveBoundParams = serde_json::from_str(
12756 "{\"target\":{\"kind\":\"entity\",\"entityType\":\"bookmark\",\"name\":\"\"}}",
12757 )
12758 .expect("generated inhabited parameter fixture");
12759 let _ = DocApi::new(invoker).bookmarks().remove(¶ms).await;
12760 }
12761
12762 {
12763 let params:DocBookmarksRenameBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"entity\",\"entityType\":\"bookmark\",\"name\":\"\"},\"newName\":\"\"}").expect("generated inhabited parameter fixture");
12764 let _ = DocApi::new(invoker).bookmarks().rename(¶ms).await;
12765 }
12766
12767 {
12768 let params: DocCapabilitiesCheckBoundParams =
12769 serde_json::from_str("{\"operation\":\"insert\"}")
12770 .expect("generated inhabited parameter fixture");
12771 let _ = DocApi::new(invoker).capabilities().check(¶ms).await;
12772 }
12773
12774 {
12775 let params: DocCapabilitiesGetBoundParams =
12776 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
12777 let _ = DocApi::new(invoker).capabilities().get(¶ms).await;
12778 }
12779
12780 {
12781 let params: DocCapabilitiesResolveBoundParams =
12782 serde_json::from_str("{\"operationId\":\"get\"}")
12783 .expect("generated inhabited parameter fixture");
12784 let _ = DocApi::new(invoker).capabilities().resolve(¶ms).await;
12785 }
12786
12787 {
12788 let params: DocCaptionsConfigureBoundParams = serde_json::from_str("{\"label\":\"\"}")
12789 .expect("generated inhabited parameter fixture");
12790 let _ = DocApi::new(invoker).captions().configure(¶ms).await;
12791 }
12792
12793 {
12794 let params: DocCaptionsGetBoundParams = serde_json::from_str(
12795 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"paragraph\",\"nodeId\":\"\"}}",
12796 )
12797 .expect("generated inhabited parameter fixture");
12798 let _ = DocApi::new(invoker).captions().get(¶ms).await;
12799 }
12800
12801 {
12802 let params:DocCaptionsInsertBoundParams=serde_json::from_str("{\"adjacentTo\":{\"kind\":\"block\",\"nodeType\":\"paragraph\",\"nodeId\":\"\"},\"position\":\"above\",\"label\":\"\"}").expect("generated inhabited parameter fixture");
12803 let _ = DocApi::new(invoker).captions().insert(¶ms).await;
12804 }
12805
12806 {
12807 let params: DocCaptionsListBoundParams =
12808 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
12809 let _ = DocApi::new(invoker).captions().list(¶ms).await;
12810 }
12811
12812 {
12813 let params: DocCaptionsRemoveBoundParams = serde_json::from_str(
12814 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"paragraph\",\"nodeId\":\"\"}}",
12815 )
12816 .expect("generated inhabited parameter fixture");
12817 let _ = DocApi::new(invoker).captions().remove(¶ms).await;
12818 }
12819
12820 {
12821 let params:DocCaptionsUpdateBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"paragraph\",\"nodeId\":\"\"},\"patch\":{}}").expect("generated inhabited parameter fixture");
12822 let _ = DocApi::new(invoker).captions().update(¶ms).await;
12823 }
12824
12825 {
12826 let params:DocCitationsBibliographyConfigureBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"bibliography\",\"nodeId\":\"\"},\"style\":\"\"}").expect("generated inhabited parameter fixture");
12827 let _ = DocApi::new(invoker)
12828 .citations()
12829 .bibliography()
12830 .configure(¶ms)
12831 .await;
12832 }
12833
12834 {
12835 let params: DocCitationsBibliographyGetBoundParams = serde_json::from_str(
12836 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"bibliography\",\"nodeId\":\"\"}}",
12837 )
12838 .expect("generated inhabited parameter fixture");
12839 let _ = DocApi::new(invoker)
12840 .citations()
12841 .bibliography()
12842 .get(¶ms)
12843 .await;
12844 }
12845
12846 {
12847 let params: DocCitationsBibliographyInsertBoundParams =
12848 serde_json::from_str("{\"at\":{\"kind\":\"documentStart\"}}")
12849 .expect("generated inhabited parameter fixture");
12850 let _ = DocApi::new(invoker)
12851 .citations()
12852 .bibliography()
12853 .insert(¶ms)
12854 .await;
12855 }
12856
12857 {
12858 let params: DocCitationsBibliographyRebuildBoundParams = serde_json::from_str(
12859 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"bibliography\",\"nodeId\":\"\"}}",
12860 )
12861 .expect("generated inhabited parameter fixture");
12862 let _ = DocApi::new(invoker)
12863 .citations()
12864 .bibliography()
12865 .rebuild(¶ms)
12866 .await;
12867 }
12868
12869 {
12870 let params: DocCitationsBibliographyRemoveBoundParams = serde_json::from_str(
12871 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"bibliography\",\"nodeId\":\"\"}}",
12872 )
12873 .expect("generated inhabited parameter fixture");
12874 let _ = DocApi::new(invoker)
12875 .citations()
12876 .bibliography()
12877 .remove(¶ms)
12878 .await;
12879 }
12880
12881 {
12882 let params:DocCitationsGetBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"inline\",\"nodeType\":\"citation\",\"anchor\":{\"start\":{\"blockId\":\"\",\"offset\":0},\"end\":{\"blockId\":\"\",\"offset\":0}}}}").expect("generated inhabited parameter fixture");
12883 let _ = DocApi::new(invoker).citations().get(¶ms).await;
12884 }
12885
12886 {
12887 let params: DocCitationsInsertBoundParams =
12888 serde_json::from_str("{\"at\":{\"kind\":\"text\",\"segments\":[]},\"sourceIds\":[]}")
12889 .expect("generated inhabited parameter fixture");
12890 let _ = DocApi::new(invoker).citations().insert(¶ms).await;
12891 }
12892
12893 {
12894 let params: DocCitationsListBoundParams =
12895 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
12896 let _ = DocApi::new(invoker).citations().list(¶ms).await;
12897 }
12898
12899 {
12900 let params:DocCitationsRemoveBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"inline\",\"nodeType\":\"citation\",\"anchor\":{\"start\":{\"blockId\":\"\",\"offset\":0},\"end\":{\"blockId\":\"\",\"offset\":0}}}}").expect("generated inhabited parameter fixture");
12901 let _ = DocApi::new(invoker).citations().remove(¶ms).await;
12902 }
12903
12904 {
12905 let params:DocCitationsSourcesGetBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"entity\",\"entityType\":\"citationSource\",\"sourceId\":\"\"}}").expect("generated inhabited parameter fixture");
12906 let _ = DocApi::new(invoker)
12907 .citations()
12908 .sources()
12909 .get(¶ms)
12910 .await;
12911 }
12912
12913 {
12914 let params: DocCitationsSourcesInsertBoundParams =
12915 serde_json::from_str("{\"type\":\"book\",\"fields\":{}}")
12916 .expect("generated inhabited parameter fixture");
12917 let _ = DocApi::new(invoker)
12918 .citations()
12919 .sources()
12920 .insert(¶ms)
12921 .await;
12922 }
12923
12924 {
12925 let params: DocCitationsSourcesListBoundParams =
12926 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
12927 let _ = DocApi::new(invoker)
12928 .citations()
12929 .sources()
12930 .list(¶ms)
12931 .await;
12932 }
12933
12934 {
12935 let params:DocCitationsSourcesRemoveBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"entity\",\"entityType\":\"citationSource\",\"sourceId\":\"\"}}").expect("generated inhabited parameter fixture");
12936 let _ = DocApi::new(invoker)
12937 .citations()
12938 .sources()
12939 .remove(¶ms)
12940 .await;
12941 }
12942
12943 {
12944 let params:DocCitationsSourcesUpdateBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"entity\",\"entityType\":\"citationSource\",\"sourceId\":\"\"},\"patch\":{}}").expect("generated inhabited parameter fixture");
12945 let _ = DocApi::new(invoker)
12946 .citations()
12947 .sources()
12948 .update(¶ms)
12949 .await;
12950 }
12951
12952 {
12953 let params:DocCitationsUpdateBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"inline\",\"nodeType\":\"citation\",\"anchor\":{\"start\":{\"blockId\":\"\",\"offset\":0},\"end\":{\"blockId\":\"\",\"offset\":0}}},\"patch\":{}}").expect("generated inhabited parameter fixture");
12954 let _ = DocApi::new(invoker).citations().update(¶ms).await;
12955 }
12956
12957 {
12958 let params: DocClearContentBoundParams =
12959 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
12960 let _ = DocApi::new(invoker).clear_content(¶ms).await;
12961 }
12962
12963 {
12964 let params: DocClipboardInsertBoundParams =
12965 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
12966 let _ = DocApi::new(invoker).clipboard().insert(¶ms).await;
12967 }
12968
12969 {
12970 let params: DocClipboardParseBoundParams =
12971 serde_json::from_str("{\"items\":[]}").expect("generated inhabited parameter fixture");
12972 let _ = DocApi::new(invoker).clipboard().parse(¶ms).await;
12973 }
12974
12975 {
12976 let params: DocClipboardSerializeSelectionBoundParams =
12977 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
12978 let _ = DocApi::new(invoker)
12979 .clipboard()
12980 .serialize_selection(¶ms)
12981 .await;
12982 }
12983
12984 {
12985 let params: DocCloseBoundParams =
12986 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
12987 let _ = DocApi::new(invoker).close(¶ms).await;
12988 }
12989
12990 {
12991 let params: DocCommentsCreateBoundParams =
12992 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
12993 let _ = DocApi::new(invoker).comments().create(¶ms).await;
12994 }
12995
12996 {
12997 let params: DocCommentsDeleteBoundParams =
12998 serde_json::from_str("{\"id\":\"\"}").expect("generated inhabited parameter fixture");
12999 let _ = DocApi::new(invoker).comments().delete(¶ms).await;
13000 }
13001
13002 {
13003 let params: DocCommentsGetBoundParams =
13004 serde_json::from_str("{\"id\":\"\"}").expect("generated inhabited parameter fixture");
13005 let _ = DocApi::new(invoker).comments().get(¶ms).await;
13006 }
13007
13008 {
13009 let params: DocCommentsListBoundParams =
13010 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13011 let _ = DocApi::new(invoker).comments().list(¶ms).await;
13012 }
13013
13014 {
13015 let params: DocCommentsPatchBoundParams =
13016 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13017 let _ = DocApi::new(invoker).comments().patch(¶ms).await;
13018 }
13019
13020 {
13021 let params:DocContentControlsAppendContentBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"content\":\"\"}").expect("generated inhabited parameter fixture");
13022 let _ = DocApi::new(invoker)
13023 .content_controls()
13024 .append_content(¶ms)
13025 .await;
13026 }
13027
13028 {
13029 let params: DocContentControlsCheckboxGetStateBoundParams = serde_json::from_str(
13030 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
13031 )
13032 .expect("generated inhabited parameter fixture");
13033 let _ = DocApi::new(invoker)
13034 .content_controls()
13035 .checkbox()
13036 .get_state(¶ms)
13037 .await;
13038 }
13039
13040 {
13041 let params:DocContentControlsCheckboxSetStateBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"checked\":false}").expect("generated inhabited parameter fixture");
13042 let _ = DocApi::new(invoker)
13043 .content_controls()
13044 .checkbox()
13045 .set_state(¶ms)
13046 .await;
13047 }
13048
13049 {
13050 let params:DocContentControlsCheckboxSetSymbolPairBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"checkedSymbol\":{},\"uncheckedSymbol\":{}}").expect("generated inhabited parameter fixture");
13051 let _ = DocApi::new(invoker)
13052 .content_controls()
13053 .checkbox()
13054 .set_symbol_pair(¶ms)
13055 .await;
13056 }
13057
13058 {
13059 let params: DocContentControlsCheckboxToggleBoundParams = serde_json::from_str(
13060 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
13061 )
13062 .expect("generated inhabited parameter fixture");
13063 let _ = DocApi::new(invoker)
13064 .content_controls()
13065 .checkbox()
13066 .toggle(¶ms)
13067 .await;
13068 }
13069
13070 {
13071 let params: DocContentControlsChoiceListGetItemsBoundParams = serde_json::from_str(
13072 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
13073 )
13074 .expect("generated inhabited parameter fixture");
13075 let _ = DocApi::new(invoker)
13076 .content_controls()
13077 .choice_list()
13078 .get_items(¶ms)
13079 .await;
13080 }
13081
13082 {
13083 let params: DocContentControlsChoiceListSetItemsBoundParams = serde_json::from_str(
13084 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"items\":[]}",
13085 )
13086 .expect("generated inhabited parameter fixture");
13087 let _ = DocApi::new(invoker)
13088 .content_controls()
13089 .choice_list()
13090 .set_items(¶ms)
13091 .await;
13092 }
13093
13094 {
13095 let params: DocContentControlsChoiceListSetSelectedBoundParams = serde_json::from_str(
13096 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"value\":\"\"}",
13097 )
13098 .expect("generated inhabited parameter fixture");
13099 let _ = DocApi::new(invoker)
13100 .content_controls()
13101 .choice_list()
13102 .set_selected(¶ms)
13103 .await;
13104 }
13105
13106 {
13107 let params: DocContentControlsClearBindingBoundParams = serde_json::from_str(
13108 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
13109 )
13110 .expect("generated inhabited parameter fixture");
13111 let _ = DocApi::new(invoker)
13112 .content_controls()
13113 .clear_binding(¶ms)
13114 .await;
13115 }
13116
13117 {
13118 let params: DocContentControlsClearContentBoundParams = serde_json::from_str(
13119 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
13120 )
13121 .expect("generated inhabited parameter fixture");
13122 let _ = DocApi::new(invoker)
13123 .content_controls()
13124 .clear_content(¶ms)
13125 .await;
13126 }
13127
13128 {
13129 let params:DocContentControlsCopyBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"destination\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}").expect("generated inhabited parameter fixture");
13130 let _ = DocApi::new(invoker).content_controls().copy(¶ms).await;
13131 }
13132
13133 {
13134 let params: DocContentControlsDateClearValueBoundParams = serde_json::from_str(
13135 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
13136 )
13137 .expect("generated inhabited parameter fixture");
13138 let _ = DocApi::new(invoker)
13139 .content_controls()
13140 .date()
13141 .clear_value(¶ms)
13142 .await;
13143 }
13144
13145 {
13146 let params:DocContentControlsDateSetCalendarBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"calendar\":\"\"}").expect("generated inhabited parameter fixture");
13147 let _ = DocApi::new(invoker)
13148 .content_controls()
13149 .date()
13150 .set_calendar(¶ms)
13151 .await;
13152 }
13153
13154 {
13155 let params:DocContentControlsDateSetDisplayFormatBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"format\":\"\"}").expect("generated inhabited parameter fixture");
13156 let _ = DocApi::new(invoker)
13157 .content_controls()
13158 .date()
13159 .set_display_format(¶ms)
13160 .await;
13161 }
13162
13163 {
13164 let params:DocContentControlsDateSetDisplayLocaleBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"locale\":\"\"}").expect("generated inhabited parameter fixture");
13165 let _ = DocApi::new(invoker)
13166 .content_controls()
13167 .date()
13168 .set_display_locale(¶ms)
13169 .await;
13170 }
13171
13172 {
13173 let params:DocContentControlsDateSetStorageFormatBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"format\":\"\"}").expect("generated inhabited parameter fixture");
13174 let _ = DocApi::new(invoker)
13175 .content_controls()
13176 .date()
13177 .set_storage_format(¶ms)
13178 .await;
13179 }
13180
13181 {
13182 let params: DocContentControlsDateSetValueBoundParams = serde_json::from_str(
13183 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"value\":\"\"}",
13184 )
13185 .expect("generated inhabited parameter fixture");
13186 let _ = DocApi::new(invoker)
13187 .content_controls()
13188 .date()
13189 .set_value(¶ms)
13190 .await;
13191 }
13192
13193 {
13194 let params: DocContentControlsDeleteBoundParams = serde_json::from_str(
13195 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
13196 )
13197 .expect("generated inhabited parameter fixture");
13198 let _ = DocApi::new(invoker)
13199 .content_controls()
13200 .delete(¶ms)
13201 .await;
13202 }
13203
13204 {
13205 let params: DocContentControlsGetBoundParams = serde_json::from_str(
13206 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
13207 )
13208 .expect("generated inhabited parameter fixture");
13209 let _ = DocApi::new(invoker).content_controls().get(¶ms).await;
13210 }
13211
13212 {
13213 let params: DocContentControlsGetBindingBoundParams = serde_json::from_str(
13214 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
13215 )
13216 .expect("generated inhabited parameter fixture");
13217 let _ = DocApi::new(invoker)
13218 .content_controls()
13219 .get_binding(¶ms)
13220 .await;
13221 }
13222
13223 {
13224 let params: DocContentControlsGetContentBoundParams = serde_json::from_str(
13225 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
13226 )
13227 .expect("generated inhabited parameter fixture");
13228 let _ = DocApi::new(invoker)
13229 .content_controls()
13230 .get_content(¶ms)
13231 .await;
13232 }
13233
13234 {
13235 let params: DocContentControlsGetParentBoundParams = serde_json::from_str(
13236 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
13237 )
13238 .expect("generated inhabited parameter fixture");
13239 let _ = DocApi::new(invoker)
13240 .content_controls()
13241 .get_parent(¶ms)
13242 .await;
13243 }
13244
13245 {
13246 let params: DocContentControlsGetRawPropertiesBoundParams = serde_json::from_str(
13247 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
13248 )
13249 .expect("generated inhabited parameter fixture");
13250 let _ = DocApi::new(invoker)
13251 .content_controls()
13252 .get_raw_properties(¶ms)
13253 .await;
13254 }
13255
13256 {
13257 let params: DocContentControlsGroupUngroupBoundParams = serde_json::from_str(
13258 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
13259 )
13260 .expect("generated inhabited parameter fixture");
13261 let _ = DocApi::new(invoker)
13262 .content_controls()
13263 .group()
13264 .ungroup(¶ms)
13265 .await;
13266 }
13267
13268 {
13269 let params: DocContentControlsGroupWrapBoundParams = serde_json::from_str(
13270 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
13271 )
13272 .expect("generated inhabited parameter fixture");
13273 let _ = DocApi::new(invoker)
13274 .content_controls()
13275 .group()
13276 .wrap(¶ms)
13277 .await;
13278 }
13279
13280 {
13281 let params:DocContentControlsInsertAfterBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"content\":\"\"}").expect("generated inhabited parameter fixture");
13282 let _ = DocApi::new(invoker)
13283 .content_controls()
13284 .insert_after(¶ms)
13285 .await;
13286 }
13287
13288 {
13289 let params:DocContentControlsInsertBeforeBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"content\":\"\"}").expect("generated inhabited parameter fixture");
13290 let _ = DocApi::new(invoker)
13291 .content_controls()
13292 .insert_before(¶ms)
13293 .await;
13294 }
13295
13296 {
13297 let params: DocContentControlsListBoundParams =
13298 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13299 let _ = DocApi::new(invoker).content_controls().list(¶ms).await;
13300 }
13301
13302 {
13303 let params: DocContentControlsListChildrenBoundParams = serde_json::from_str(
13304 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
13305 )
13306 .expect("generated inhabited parameter fixture");
13307 let _ = DocApi::new(invoker)
13308 .content_controls()
13309 .list_children(¶ms)
13310 .await;
13311 }
13312
13313 {
13314 let params: DocContentControlsListInRangeBoundParams =
13315 serde_json::from_str("{\"startBlockId\":\"\",\"endBlockId\":\"\"}")
13316 .expect("generated inhabited parameter fixture");
13317 let _ = DocApi::new(invoker)
13318 .content_controls()
13319 .list_in_range(¶ms)
13320 .await;
13321 }
13322
13323 {
13324 let params:DocContentControlsMoveBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"destination\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}").expect("generated inhabited parameter fixture");
13325 let _ = DocApi::new(invoker).content_controls().move_(¶ms).await;
13326 }
13327
13328 {
13329 let params: DocContentControlsNormalizeTagPayloadBoundParams = serde_json::from_str(
13330 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
13331 )
13332 .expect("generated inhabited parameter fixture");
13333 let _ = DocApi::new(invoker)
13334 .content_controls()
13335 .normalize_tag_payload(¶ms)
13336 .await;
13337 }
13338
13339 {
13340 let params: DocContentControlsNormalizeWordCompatibilityBoundParams = serde_json::from_str(
13341 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
13342 )
13343 .expect("generated inhabited parameter fixture");
13344 let _ = DocApi::new(invoker)
13345 .content_controls()
13346 .normalize_word_compatibility(¶ms)
13347 .await;
13348 }
13349
13350 {
13351 let params: DocContentControlsPatchBoundParams = serde_json::from_str(
13352 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
13353 )
13354 .expect("generated inhabited parameter fixture");
13355 let _ = DocApi::new(invoker).content_controls().patch(¶ms).await;
13356 }
13357
13358 {
13359 let params: DocContentControlsPatchRawPropertiesBoundParams = serde_json::from_str(
13360 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"patches\":[]}",
13361 )
13362 .expect("generated inhabited parameter fixture");
13363 let _ = DocApi::new(invoker)
13364 .content_controls()
13365 .patch_raw_properties(¶ms)
13366 .await;
13367 }
13368
13369 {
13370 let params:DocContentControlsPrependContentBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"content\":\"\"}").expect("generated inhabited parameter fixture");
13371 let _ = DocApi::new(invoker)
13372 .content_controls()
13373 .prepend_content(¶ms)
13374 .await;
13375 }
13376
13377 {
13378 let params: DocContentControlsRepeatingSectionCloneItemBoundParams = serde_json::from_str(
13379 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"index\":0}",
13380 )
13381 .expect("generated inhabited parameter fixture");
13382 let _ = DocApi::new(invoker)
13383 .content_controls()
13384 .repeating_section()
13385 .clone_item(¶ms)
13386 .await;
13387 }
13388
13389 {
13390 let params: DocContentControlsRepeatingSectionDeleteItemBoundParams = serde_json::from_str(
13391 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"index\":0}",
13392 )
13393 .expect("generated inhabited parameter fixture");
13394 let _ = DocApi::new(invoker)
13395 .content_controls()
13396 .repeating_section()
13397 .delete_item(¶ms)
13398 .await;
13399 }
13400
13401 {
13402 let params:DocContentControlsRepeatingSectionInsertItemAfterBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"index\":0}").expect("generated inhabited parameter fixture");
13403 let _ = DocApi::new(invoker)
13404 .content_controls()
13405 .repeating_section()
13406 .insert_item_after(¶ms)
13407 .await;
13408 }
13409
13410 {
13411 let params:DocContentControlsRepeatingSectionInsertItemBeforeBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"index\":0}").expect("generated inhabited parameter fixture");
13412 let _ = DocApi::new(invoker)
13413 .content_controls()
13414 .repeating_section()
13415 .insert_item_before(¶ms)
13416 .await;
13417 }
13418
13419 {
13420 let params: DocContentControlsRepeatingSectionListItemsBoundParams = serde_json::from_str(
13421 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
13422 )
13423 .expect("generated inhabited parameter fixture");
13424 let _ = DocApi::new(invoker)
13425 .content_controls()
13426 .repeating_section()
13427 .list_items(¶ms)
13428 .await;
13429 }
13430
13431 {
13432 let params:DocContentControlsRepeatingSectionSetAllowInsertDeleteBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"allow\":false}").expect("generated inhabited parameter fixture");
13433 let _ = DocApi::new(invoker)
13434 .content_controls()
13435 .repeating_section()
13436 .set_allow_insert_delete(¶ms)
13437 .await;
13438 }
13439
13440 {
13441 let params:DocContentControlsReplaceContentBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"content\":\"\"}").expect("generated inhabited parameter fixture");
13442 let _ = DocApi::new(invoker)
13443 .content_controls()
13444 .replace_content(¶ms)
13445 .await;
13446 }
13447
13448 {
13449 let params: DocContentControlsSelectByTagBoundParams =
13450 serde_json::from_str("{\"tag\":\"\"}").expect("generated inhabited parameter fixture");
13451 let _ = DocApi::new(invoker)
13452 .content_controls()
13453 .select_by_tag(¶ms)
13454 .await;
13455 }
13456
13457 {
13458 let params: DocContentControlsSelectByTitleBoundParams =
13459 serde_json::from_str("{\"title\":\"\"}")
13460 .expect("generated inhabited parameter fixture");
13461 let _ = DocApi::new(invoker)
13462 .content_controls()
13463 .select_by_title(¶ms)
13464 .await;
13465 }
13466
13467 {
13468 let params:DocContentControlsSetBindingBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"storeItemId\":\"\",\"xpath\":\"\"}").expect("generated inhabited parameter fixture");
13469 let _ = DocApi::new(invoker)
13470 .content_controls()
13471 .set_binding(¶ms)
13472 .await;
13473 }
13474
13475 {
13476 let params:DocContentControlsSetLockModeBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"lockMode\":\"unlocked\"}").expect("generated inhabited parameter fixture");
13477 let _ = DocApi::new(invoker)
13478 .content_controls()
13479 .set_lock_mode(¶ms)
13480 .await;
13481 }
13482
13483 {
13484 let params:DocContentControlsSetTypeBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"controlType\":\"\"}").expect("generated inhabited parameter fixture");
13485 let _ = DocApi::new(invoker)
13486 .content_controls()
13487 .set_type(¶ms)
13488 .await;
13489 }
13490
13491 {
13492 let params: DocContentControlsTextClearValueBoundParams = serde_json::from_str(
13493 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
13494 )
13495 .expect("generated inhabited parameter fixture");
13496 let _ = DocApi::new(invoker)
13497 .content_controls()
13498 .text()
13499 .clear_value(¶ms)
13500 .await;
13501 }
13502
13503 {
13504 let params:DocContentControlsTextSetMultilineBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"multiline\":false}").expect("generated inhabited parameter fixture");
13505 let _ = DocApi::new(invoker)
13506 .content_controls()
13507 .text()
13508 .set_multiline(¶ms)
13509 .await;
13510 }
13511
13512 {
13513 let params: DocContentControlsTextSetValueBoundParams = serde_json::from_str(
13514 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"value\":\"\"}",
13515 )
13516 .expect("generated inhabited parameter fixture");
13517 let _ = DocApi::new(invoker)
13518 .content_controls()
13519 .text()
13520 .set_value(¶ms)
13521 .await;
13522 }
13523
13524 {
13525 let params: DocContentControlsUnwrapBoundParams = serde_json::from_str(
13526 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
13527 )
13528 .expect("generated inhabited parameter fixture");
13529 let _ = DocApi::new(invoker)
13530 .content_controls()
13531 .unwrap(¶ms)
13532 .await;
13533 }
13534
13535 {
13536 let params: DocContentControlsValidateWordCompatibilityBoundParams = serde_json::from_str(
13537 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
13538 )
13539 .expect("generated inhabited parameter fixture");
13540 let _ = DocApi::new(invoker)
13541 .content_controls()
13542 .validate_word_compatibility(¶ms)
13543 .await;
13544 }
13545
13546 {
13547 let params:DocContentControlsWrapBoundParams=serde_json::from_str("{\"kind\":\"block\",\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}").expect("generated inhabited parameter fixture");
13548 let _ = DocApi::new(invoker).content_controls().wrap(¶ms).await;
13549 }
13550
13551 {
13552 let params: DocCreateContentControlBoundParams =
13553 serde_json::from_str("{\"kind\":\"block\"}")
13554 .expect("generated inhabited parameter fixture");
13555 let _ = DocApi::new(invoker).create().content_control(¶ms).await;
13556 }
13557
13558 {
13559 let params: DocCreateHeadingBoundParams =
13560 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13561 let _ = DocApi::new(invoker).create().heading(¶ms).await;
13562 }
13563
13564 {
13565 let params: DocCreateImageBoundParams =
13566 serde_json::from_str("{\"src\":\"\"}").expect("generated inhabited parameter fixture");
13567 let _ = DocApi::new(invoker).create().image(¶ms).await;
13568 }
13569
13570 {
13571 let params: DocCreateParagraphBoundParams =
13572 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13573 let _ = DocApi::new(invoker).create().paragraph(¶ms).await;
13574 }
13575
13576 {
13577 let params: DocCreateSectionBreakBoundParams =
13578 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13579 let _ = DocApi::new(invoker).create().section_break(¶ms).await;
13580 }
13581
13582 {
13583 let params: DocCreateTableBoundParams = serde_json::from_str("{\"rows\":0,\"columns\":0}")
13584 .expect("generated inhabited parameter fixture");
13585 let _ = DocApi::new(invoker).create().table(¶ms).await;
13586 }
13587
13588 {
13589 let params: DocCreateTableOfContentsBoundParams =
13590 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13591 let _ = DocApi::new(invoker)
13592 .create()
13593 .table_of_contents(¶ms)
13594 .await;
13595 }
13596
13597 {
13598 let params:DocCrossRefsGetBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"inline\",\"nodeType\":\"crossRef\",\"anchor\":{\"start\":{\"blockId\":\"\",\"offset\":0},\"end\":{\"blockId\":\"\",\"offset\":0}}}}").expect("generated inhabited parameter fixture");
13599 let _ = DocApi::new(invoker).cross_refs().get(¶ms).await;
13600 }
13601
13602 {
13603 let params:DocCrossRefsInsertBoundParams=serde_json::from_str("{\"at\":{\"kind\":\"text\",\"segments\":[]},\"target\":{\"kind\":\"bookmark\",\"name\":\"\"},\"display\":\"content\"}").expect("generated inhabited parameter fixture");
13604 let _ = DocApi::new(invoker).cross_refs().insert(¶ms).await;
13605 }
13606
13607 {
13608 let params: DocCrossRefsListBoundParams =
13609 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13610 let _ = DocApi::new(invoker).cross_refs().list(¶ms).await;
13611 }
13612
13613 {
13614 let params:DocCrossRefsRebuildBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"inline\",\"nodeType\":\"crossRef\",\"anchor\":{\"start\":{\"blockId\":\"\",\"offset\":0},\"end\":{\"blockId\":\"\",\"offset\":0}}}}").expect("generated inhabited parameter fixture");
13615 let _ = DocApi::new(invoker).cross_refs().rebuild(¶ms).await;
13616 }
13617
13618 {
13619 let params:DocCrossRefsRemoveBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"inline\",\"nodeType\":\"crossRef\",\"anchor\":{\"start\":{\"blockId\":\"\",\"offset\":0},\"end\":{\"blockId\":\"\",\"offset\":0}}}}").expect("generated inhabited parameter fixture");
13620 let _ = DocApi::new(invoker).cross_refs().remove(¶ms).await;
13621 }
13622
13623 {
13624 let params: DocCustomXmlPartsCreateBoundParams = serde_json::from_str("{\"content\":\"\"}")
13625 .expect("generated inhabited parameter fixture");
13626 let _ = DocApi::new(invoker)
13627 .custom_xml()
13628 .parts()
13629 .create(¶ms)
13630 .await;
13631 }
13632
13633 {
13634 let params: DocCustomXmlPartsGetBoundParams =
13635 serde_json::from_str("{\"target\":{\"id\":\"\"}}")
13636 .expect("generated inhabited parameter fixture");
13637 let _ = DocApi::new(invoker).custom_xml().parts().get(¶ms).await;
13638 }
13639
13640 {
13641 let params: DocCustomXmlPartsListBoundParams =
13642 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13643 let _ = DocApi::new(invoker)
13644 .custom_xml()
13645 .parts()
13646 .list(¶ms)
13647 .await;
13648 }
13649
13650 {
13651 let params: DocCustomXmlPartsPatchBoundParams =
13652 serde_json::from_str("{\"target\":{\"id\":\"\"}}")
13653 .expect("generated inhabited parameter fixture");
13654 let _ = DocApi::new(invoker)
13655 .custom_xml()
13656 .parts()
13657 .patch(¶ms)
13658 .await;
13659 }
13660
13661 {
13662 let params: DocCustomXmlPartsRemoveBoundParams =
13663 serde_json::from_str("{\"target\":{\"id\":\"\"}}")
13664 .expect("generated inhabited parameter fixture");
13665 let _ = DocApi::new(invoker)
13666 .custom_xml()
13667 .parts()
13668 .remove(¶ms)
13669 .await;
13670 }
13671
13672 {
13673 let params: DocDeleteBoundParams =
13674 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13675 let _ = DocApi::new(invoker).delete(¶ms).await;
13676 }
13677
13678 {
13679 let params: DocDescribeParams =
13680 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13681 let _ = ClientApi::new(invoker).describe(¶ms).await;
13682 }
13683
13684 {
13685 let params: DocDescribeCommandParams = serde_json::from_str("{\"operationId\":\"\"}")
13686 .expect("generated inhabited parameter fixture");
13687 let _ = ClientApi::new(invoker).describe_command(¶ms).await;
13688 }
13689
13690 {
13691 let params:DocDiffApplyBoundParams=serde_json::from_str("{\"diff\":{\"version\":\"sd-diff-payload/v1\",\"engine\":\"superdoc-v2\",\"baseFingerprint\":\"\",\"targetFingerprint\":\"\",\"coverage\":{\"body\":true,\"comments\":false,\"styles\":false,\"numbering\":false,\"headerFooters\":false},\"summary\":{\"hasChanges\":false,\"changedComponents\":[],\"body\":{\"hasChanges\":false},\"comments\":{\"hasChanges\":false},\"styles\":{\"hasChanges\":false},\"numbering\":{\"hasChanges\":false},\"headerFooters\":{\"hasChanges\":false},\"parts\":{\"hasChanges\":false}},\"payload\":{}}}").expect("generated inhabited parameter fixture");
13692 let _ = DocApi::new(invoker).diff().apply(¶ms).await;
13693 }
13694
13695 {
13696 let params: DocDiffCaptureBoundParams =
13697 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13698 let _ = DocApi::new(invoker).diff().capture(¶ms).await;
13699 }
13700
13701 {
13702 let params:DocDiffCompareBoundParams=serde_json::from_str("{\"targetSnapshot\":{\"version\":\"sd-diff-snapshot/v1\",\"engine\":\"superdoc-v2\",\"fingerprint\":\"\",\"coverage\":{\"body\":true,\"comments\":false,\"styles\":false,\"numbering\":false,\"headerFooters\":false},\"payload\":{}}}").expect("generated inhabited parameter fixture");
13703 let _ = DocApi::new(invoker).diff().compare(¶ms).await;
13704 }
13705
13706 {
13707 let params: DocDiscoverParams = serde_json::from_str("{\"query\":\"\"}")
13708 .expect("generated inhabited parameter fixture");
13709 let _ = InternalApi::new(invoker).discover(¶ms).await;
13710 }
13711
13712 {
13713 let params: DocExecuteCodeBoundParams =
13714 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13715 let _ = DocApi::new(invoker).execute_code(¶ms).await;
13716 }
13717
13718 {
13719 let params: DocExportToDocxBoundParams =
13720 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13721 let _ = DocApi::new(invoker).export().to_docx(¶ms).await;
13722 }
13723
13724 {
13725 let params: DocExtractBoundParams =
13726 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13727 let _ = DocApi::new(invoker).extract(¶ms).await;
13728 }
13729
13730 {
13731 let params: DocFieldsGetBoundParams = serde_json::from_str(
13732 "{\"target\":{\"kind\":\"field\",\"blockId\":\"\",\"occurrenceIndex\":0}}",
13733 )
13734 .expect("generated inhabited parameter fixture");
13735 let _ = DocApi::new(invoker).fields().get(¶ms).await;
13736 }
13737
13738 {
13739 let params: DocFieldsInsertBoundParams = serde_json::from_str(
13740 "{\"mode\":\"raw\",\"at\":{\"kind\":\"text\",\"segments\":[]},\"instruction\":\"\"}",
13741 )
13742 .expect("generated inhabited parameter fixture");
13743 let _ = DocApi::new(invoker).fields().insert(¶ms).await;
13744 }
13745
13746 {
13747 let params: DocFieldsListBoundParams =
13748 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13749 let _ = DocApi::new(invoker).fields().list(¶ms).await;
13750 }
13751
13752 {
13753 let params: DocFieldsRebuildBoundParams = serde_json::from_str(
13754 "{\"target\":{\"kind\":\"field\",\"blockId\":\"\",\"occurrenceIndex\":0}}",
13755 )
13756 .expect("generated inhabited parameter fixture");
13757 let _ = DocApi::new(invoker).fields().rebuild(¶ms).await;
13758 }
13759
13760 {
13761 let params:DocFieldsRemoveBoundParams=serde_json::from_str("{\"mode\":\"raw\",\"target\":{\"kind\":\"field\",\"blockId\":\"\",\"occurrenceIndex\":0}}").expect("generated inhabited parameter fixture");
13762 let _ = DocApi::new(invoker).fields().remove(¶ms).await;
13763 }
13764
13765 {
13766 let params: DocFindBoundParams =
13767 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13768 let _ = DocApi::new(invoker).find(¶ms).await;
13769 }
13770
13771 {
13772 let params: DocFootnotesConfigureBoundParams =
13773 serde_json::from_str("{\"type\":\"footnote\",\"scope\":{\"kind\":\"document\"}}")
13774 .expect("generated inhabited parameter fixture");
13775 let _ = DocApi::new(invoker).footnotes().configure(¶ms).await;
13776 }
13777
13778 {
13779 let params: DocFootnotesGetBoundParams = serde_json::from_str(
13780 "{\"target\":{\"kind\":\"entity\",\"entityType\":\"footnote\",\"noteId\":\"\"}}",
13781 )
13782 .expect("generated inhabited parameter fixture");
13783 let _ = DocApi::new(invoker).footnotes().get(¶ms).await;
13784 }
13785
13786 {
13787 let params: DocFootnotesInsertBoundParams = serde_json::from_str("{\"type\":\"footnote\"}")
13788 .expect("generated inhabited parameter fixture");
13789 let _ = DocApi::new(invoker).footnotes().insert(¶ms).await;
13790 }
13791
13792 {
13793 let params: DocFootnotesListBoundParams =
13794 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13795 let _ = DocApi::new(invoker).footnotes().list(¶ms).await;
13796 }
13797
13798 {
13799 let params: DocFootnotesRemoveBoundParams = serde_json::from_str(
13800 "{\"target\":{\"kind\":\"entity\",\"entityType\":\"footnote\",\"noteId\":\"\"}}",
13801 )
13802 .expect("generated inhabited parameter fixture");
13803 let _ = DocApi::new(invoker).footnotes().remove(¶ms).await;
13804 }
13805
13806 {
13807 let params:DocFootnotesUpdateBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"entity\",\"entityType\":\"footnote\",\"noteId\":\"\"},\"patch\":{\"content\":\"\"}}").expect("generated inhabited parameter fixture");
13808 let _ = DocApi::new(invoker).footnotes().update(¶ms).await;
13809 }
13810
13811 {
13812 let params: DocFormatApplyBoundParams =
13813 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13814 let _ = DocApi::new(invoker).format().apply(¶ms).await;
13815 }
13816
13817 {
13818 let params: DocFormatBCsBoundParams =
13819 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13820 let _ = DocApi::new(invoker).format().b_cs(¶ms).await;
13821 }
13822
13823 {
13824 let params: DocFormatBoldBoundParams =
13825 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13826 let _ = DocApi::new(invoker).format().bold(¶ms).await;
13827 }
13828
13829 {
13830 let params: DocFormatBorderBoundParams =
13831 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13832 let _ = DocApi::new(invoker).format().border(¶ms).await;
13833 }
13834
13835 {
13836 let params: DocFormatCapsBoundParams =
13837 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13838 let _ = DocApi::new(invoker).format().caps(¶ms).await;
13839 }
13840
13841 {
13842 let params: DocFormatCharScaleBoundParams =
13843 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13844 let _ = DocApi::new(invoker).format().char_scale(¶ms).await;
13845 }
13846
13847 {
13848 let params: DocFormatColorBoundParams =
13849 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13850 let _ = DocApi::new(invoker).format().color(¶ms).await;
13851 }
13852
13853 {
13854 let params: DocFormatContextualAlternatesBoundParams =
13855 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13856 let _ = DocApi::new(invoker)
13857 .format()
13858 .contextual_alternates(¶ms)
13859 .await;
13860 }
13861
13862 {
13863 let params: DocFormatCsBoundParams =
13864 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13865 let _ = DocApi::new(invoker).format().cs(¶ms).await;
13866 }
13867
13868 {
13869 let params: DocFormatDstrikeBoundParams =
13870 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13871 let _ = DocApi::new(invoker).format().dstrike(¶ms).await;
13872 }
13873
13874 {
13875 let params: DocFormatEastAsianLayoutBoundParams =
13876 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13877 let _ = DocApi::new(invoker)
13878 .format()
13879 .east_asian_layout(¶ms)
13880 .await;
13881 }
13882
13883 {
13884 let params: DocFormatEmBoundParams =
13885 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13886 let _ = DocApi::new(invoker).format().em(¶ms).await;
13887 }
13888
13889 {
13890 let params: DocFormatEmbossBoundParams =
13891 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13892 let _ = DocApi::new(invoker).format().emboss(¶ms).await;
13893 }
13894
13895 {
13896 let params: DocFormatFitTextBoundParams =
13897 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13898 let _ = DocApi::new(invoker).format().fit_text(¶ms).await;
13899 }
13900
13901 {
13902 let params: DocFormatFontFamilyBoundParams =
13903 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13904 let _ = DocApi::new(invoker).format().font_family(¶ms).await;
13905 }
13906
13907 {
13908 let params: DocFormatFontSizeBoundParams =
13909 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13910 let _ = DocApi::new(invoker).format().font_size(¶ms).await;
13911 }
13912
13913 {
13914 let params: DocFormatFontSizeCsBoundParams =
13915 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13916 let _ = DocApi::new(invoker).format().font_size_cs(¶ms).await;
13917 }
13918
13919 {
13920 let params: DocFormatHighlightBoundParams =
13921 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13922 let _ = DocApi::new(invoker).format().highlight(¶ms).await;
13923 }
13924
13925 {
13926 let params: DocFormatICsBoundParams =
13927 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13928 let _ = DocApi::new(invoker).format().i_cs(¶ms).await;
13929 }
13930
13931 {
13932 let params: DocFormatImprintBoundParams =
13933 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13934 let _ = DocApi::new(invoker).format().imprint(¶ms).await;
13935 }
13936
13937 {
13938 let params: DocFormatItalicBoundParams =
13939 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13940 let _ = DocApi::new(invoker).format().italic(¶ms).await;
13941 }
13942
13943 {
13944 let params: DocFormatKerningBoundParams =
13945 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13946 let _ = DocApi::new(invoker).format().kerning(¶ms).await;
13947 }
13948
13949 {
13950 let params: DocFormatLangBoundParams =
13951 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13952 let _ = DocApi::new(invoker).format().lang(¶ms).await;
13953 }
13954
13955 {
13956 let params: DocFormatLetterSpacingBoundParams =
13957 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13958 let _ = DocApi::new(invoker).format().letter_spacing(¶ms).await;
13959 }
13960
13961 {
13962 let params: DocFormatLigaturesBoundParams =
13963 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13964 let _ = DocApi::new(invoker).format().ligatures(¶ms).await;
13965 }
13966
13967 {
13968 let params: DocFormatNumFormBoundParams =
13969 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13970 let _ = DocApi::new(invoker).format().num_form(¶ms).await;
13971 }
13972
13973 {
13974 let params: DocFormatNumSpacingBoundParams =
13975 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13976 let _ = DocApi::new(invoker).format().num_spacing(¶ms).await;
13977 }
13978
13979 {
13980 let params: DocFormatOMathBoundParams =
13981 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13982 let _ = DocApi::new(invoker).format().o_math(¶ms).await;
13983 }
13984
13985 {
13986 let params: DocFormatOutlineBoundParams =
13987 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13988 let _ = DocApi::new(invoker).format().outline(¶ms).await;
13989 }
13990
13991 {
13992 let params: DocFormatParagraphClearAlignmentBoundParams =
13993 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
13994 let _ = DocApi::new(invoker)
13995 .format()
13996 .paragraph()
13997 .clear_alignment(¶ms)
13998 .await;
13999 }
14000
14001 {
14002 let params: DocFormatParagraphClearAllTabStopsBoundParams =
14003 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14004 let _ = DocApi::new(invoker)
14005 .format()
14006 .paragraph()
14007 .clear_all_tab_stops(¶ms)
14008 .await;
14009 }
14010
14011 {
14012 let params: DocFormatParagraphClearBorderBoundParams =
14013 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14014 let _ = DocApi::new(invoker)
14015 .format()
14016 .paragraph()
14017 .clear_border(¶ms)
14018 .await;
14019 }
14020
14021 {
14022 let params: DocFormatParagraphClearDirectionBoundParams =
14023 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14024 let _ = DocApi::new(invoker)
14025 .format()
14026 .paragraph()
14027 .clear_direction(¶ms)
14028 .await;
14029 }
14030
14031 {
14032 let params: DocFormatParagraphClearIndentationBoundParams =
14033 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14034 let _ = DocApi::new(invoker)
14035 .format()
14036 .paragraph()
14037 .clear_indentation(¶ms)
14038 .await;
14039 }
14040
14041 {
14042 let params: DocFormatParagraphClearShadingBoundParams =
14043 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14044 let _ = DocApi::new(invoker)
14045 .format()
14046 .paragraph()
14047 .clear_shading(¶ms)
14048 .await;
14049 }
14050
14051 {
14052 let params: DocFormatParagraphClearSpacingBoundParams =
14053 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14054 let _ = DocApi::new(invoker)
14055 .format()
14056 .paragraph()
14057 .clear_spacing(¶ms)
14058 .await;
14059 }
14060
14061 {
14062 let params: DocFormatParagraphClearTabStopBoundParams =
14063 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14064 let _ = DocApi::new(invoker)
14065 .format()
14066 .paragraph()
14067 .clear_tab_stop(¶ms)
14068 .await;
14069 }
14070
14071 {
14072 let params: DocFormatParagraphResetDirectFormattingBoundParams =
14073 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14074 let _ = DocApi::new(invoker)
14075 .format()
14076 .paragraph()
14077 .reset_direct_formatting(¶ms)
14078 .await;
14079 }
14080
14081 {
14082 let params: DocFormatParagraphSetAlignmentBoundParams =
14083 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14084 let _ = DocApi::new(invoker)
14085 .format()
14086 .paragraph()
14087 .set_alignment(¶ms)
14088 .await;
14089 }
14090
14091 {
14092 let params: DocFormatParagraphSetBorderBoundParams =
14093 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14094 let _ = DocApi::new(invoker)
14095 .format()
14096 .paragraph()
14097 .set_border(¶ms)
14098 .await;
14099 }
14100
14101 {
14102 let params: DocFormatParagraphSetDirectionBoundParams =
14103 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14104 let _ = DocApi::new(invoker)
14105 .format()
14106 .paragraph()
14107 .set_direction(¶ms)
14108 .await;
14109 }
14110
14111 {
14112 let params: DocFormatParagraphSetFlowOptionsBoundParams =
14113 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14114 let _ = DocApi::new(invoker)
14115 .format()
14116 .paragraph()
14117 .set_flow_options(¶ms)
14118 .await;
14119 }
14120
14121 {
14122 let params: DocFormatParagraphSetIndentationBoundParams =
14123 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14124 let _ = DocApi::new(invoker)
14125 .format()
14126 .paragraph()
14127 .set_indentation(¶ms)
14128 .await;
14129 }
14130
14131 {
14132 let params: DocFormatParagraphSetKeepOptionsBoundParams =
14133 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14134 let _ = DocApi::new(invoker)
14135 .format()
14136 .paragraph()
14137 .set_keep_options(¶ms)
14138 .await;
14139 }
14140
14141 {
14142 let params: DocFormatParagraphSetMarkRunPropsBoundParams =
14143 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14144 let _ = DocApi::new(invoker)
14145 .format()
14146 .paragraph()
14147 .set_mark_run_props(¶ms)
14148 .await;
14149 }
14150
14151 {
14152 let params: DocFormatParagraphSetNumberingBoundParams =
14153 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14154 let _ = DocApi::new(invoker)
14155 .format()
14156 .paragraph()
14157 .set_numbering(¶ms)
14158 .await;
14159 }
14160
14161 {
14162 let params: DocFormatParagraphSetOutlineLevelBoundParams =
14163 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14164 let _ = DocApi::new(invoker)
14165 .format()
14166 .paragraph()
14167 .set_outline_level(¶ms)
14168 .await;
14169 }
14170
14171 {
14172 let params: DocFormatParagraphSetShadingBoundParams =
14173 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14174 let _ = DocApi::new(invoker)
14175 .format()
14176 .paragraph()
14177 .set_shading(¶ms)
14178 .await;
14179 }
14180
14181 {
14182 let params: DocFormatParagraphSetSpacingBoundParams =
14183 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14184 let _ = DocApi::new(invoker)
14185 .format()
14186 .paragraph()
14187 .set_spacing(¶ms)
14188 .await;
14189 }
14190
14191 {
14192 let params: DocFormatParagraphSetTabStopBoundParams =
14193 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14194 let _ = DocApi::new(invoker)
14195 .format()
14196 .paragraph()
14197 .set_tab_stop(¶ms)
14198 .await;
14199 }
14200
14201 {
14202 let params: DocFormatPositionBoundParams =
14203 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14204 let _ = DocApi::new(invoker).format().position(¶ms).await;
14205 }
14206
14207 {
14208 let params: DocFormatReadSelectionBoundParams =
14209 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14210 let _ = DocApi::new(invoker).format().read_selection(¶ms).await;
14211 }
14212
14213 {
14214 let params: DocFormatRFontsBoundParams =
14215 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14216 let _ = DocApi::new(invoker).format().r_fonts(¶ms).await;
14217 }
14218
14219 {
14220 let params: DocFormatRStyleBoundParams =
14221 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14222 let _ = DocApi::new(invoker).format().r_style(¶ms).await;
14223 }
14224
14225 {
14226 let params: DocFormatRtlBoundParams =
14227 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14228 let _ = DocApi::new(invoker).format().rtl(¶ms).await;
14229 }
14230
14231 {
14232 let params: DocFormatShadingBoundParams =
14233 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14234 let _ = DocApi::new(invoker).format().shading(¶ms).await;
14235 }
14236
14237 {
14238 let params: DocFormatShadowBoundParams =
14239 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14240 let _ = DocApi::new(invoker).format().shadow(¶ms).await;
14241 }
14242
14243 {
14244 let params: DocFormatSmallCapsBoundParams =
14245 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14246 let _ = DocApi::new(invoker).format().small_caps(¶ms).await;
14247 }
14248
14249 {
14250 let params: DocFormatSnapToGridBoundParams =
14251 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14252 let _ = DocApi::new(invoker).format().snap_to_grid(¶ms).await;
14253 }
14254
14255 {
14256 let params: DocFormatSpecVanishBoundParams =
14257 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14258 let _ = DocApi::new(invoker).format().spec_vanish(¶ms).await;
14259 }
14260
14261 {
14262 let params: DocFormatStrikeBoundParams =
14263 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14264 let _ = DocApi::new(invoker).format().strike(¶ms).await;
14265 }
14266
14267 {
14268 let params: DocFormatStylisticSetsBoundParams =
14269 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14270 let _ = DocApi::new(invoker).format().stylistic_sets(¶ms).await;
14271 }
14272
14273 {
14274 let params: DocFormatUnderlineBoundParams =
14275 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14276 let _ = DocApi::new(invoker).format().underline(¶ms).await;
14277 }
14278
14279 {
14280 let params: DocFormatVanishBoundParams =
14281 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14282 let _ = DocApi::new(invoker).format().vanish(¶ms).await;
14283 }
14284
14285 {
14286 let params: DocFormatVertAlignBoundParams =
14287 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14288 let _ = DocApi::new(invoker).format().vert_align(¶ms).await;
14289 }
14290
14291 {
14292 let params: DocFormatWebHiddenBoundParams =
14293 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14294 let _ = DocApi::new(invoker).format().web_hidden(¶ms).await;
14295 }
14296
14297 {
14298 let params: DocFormatRangeBoundParams = serde_json::from_str("{\"properties\":{}}")
14299 .expect("generated inhabited parameter fixture");
14300 let _ = DocApi::new(invoker).format_range(¶ms).await;
14301 }
14302
14303 {
14304 let params: DocGetBoundParams =
14305 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14306 let _ = DocApi::new(invoker).get(¶ms).await;
14307 }
14308
14309 {
14310 let params: DocGetHtmlBoundParams =
14311 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14312 let _ = DocApi::new(invoker).get_html(¶ms).await;
14313 }
14314
14315 {
14316 let params: DocGetMarkdownBoundParams =
14317 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14318 let _ = DocApi::new(invoker).get_markdown(¶ms).await;
14319 }
14320
14321 {
14322 let params: DocGetNodeBoundParams =
14323 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14324 let _ = DocApi::new(invoker).get_node(¶ms).await;
14325 }
14326
14327 {
14328 let params: DocGetNodeByIdBoundParams =
14329 serde_json::from_str("{\"id\":\"\"}").expect("generated inhabited parameter fixture");
14330 let _ = DocApi::new(invoker).get_node_by_id(¶ms).await;
14331 }
14332
14333 {
14334 let params: DocGetTextBoundParams =
14335 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14336 let _ = DocApi::new(invoker).get_text(¶ms).await;
14337 }
14338
14339 {
14340 let params:DocHeaderFootersGetBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"headerFooterSlot\",\"section\":{\"kind\":\"section\",\"sectionId\":\"\"},\"headerFooterKind\":\"header\",\"variant\":\"default\"}}").expect("generated inhabited parameter fixture");
14341 let _ = DocApi::new(invoker).header_footers().get(¶ms).await;
14342 }
14343
14344 {
14345 let params: DocHeaderFootersListBoundParams =
14346 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14347 let _ = DocApi::new(invoker).header_footers().list(¶ms).await;
14348 }
14349
14350 {
14351 let params: DocHeaderFootersPageNumbersGetBoundParams =
14352 serde_json::from_str("{\"section\":{\"kind\":\"section\",\"sectionId\":\"\"}}")
14353 .expect("generated inhabited parameter fixture");
14354 let _ = DocApi::new(invoker)
14355 .header_footers()
14356 .page_numbers()
14357 .get(¶ms)
14358 .await;
14359 }
14360
14361 {
14362 let params: DocHeaderFootersPageNumbersInsertBoundParams = serde_json::from_str(
14363 "{\"section\":{\"kind\":\"section\",\"sectionId\":\"\"},\"kind\":\"header\"}",
14364 )
14365 .expect("generated inhabited parameter fixture");
14366 let _ = DocApi::new(invoker)
14367 .header_footers()
14368 .page_numbers()
14369 .insert(¶ms)
14370 .await;
14371 }
14372
14373 {
14374 let params: DocHeaderFootersPageNumbersRemoveBoundParams =
14375 serde_json::from_str("{\"section\":{\"kind\":\"section\",\"sectionId\":\"\"}}")
14376 .expect("generated inhabited parameter fixture");
14377 let _ = DocApi::new(invoker)
14378 .header_footers()
14379 .page_numbers()
14380 .remove(¶ms)
14381 .await;
14382 }
14383
14384 {
14385 let params: DocHeaderFootersPageNumbersSetBoundParams = serde_json::from_str(
14386 "{\"section\":{\"kind\":\"section\",\"sectionId\":\"\"},\"kind\":\"header\"}",
14387 )
14388 .expect("generated inhabited parameter fixture");
14389 let _ = DocApi::new(invoker)
14390 .header_footers()
14391 .page_numbers()
14392 .set(¶ms)
14393 .await;
14394 }
14395
14396 {
14397 let params: DocHeaderFootersPartsCreateBoundParams =
14398 serde_json::from_str("{\"kind\":\"header\"}")
14399 .expect("generated inhabited parameter fixture");
14400 let _ = DocApi::new(invoker)
14401 .header_footers()
14402 .parts()
14403 .create(¶ms)
14404 .await;
14405 }
14406
14407 {
14408 let params: DocHeaderFootersPartsDeleteBoundParams =
14409 serde_json::from_str("{\"target\":{\"kind\":\"headerFooterPart\",\"refId\":\"\"}}")
14410 .expect("generated inhabited parameter fixture");
14411 let _ = DocApi::new(invoker)
14412 .header_footers()
14413 .parts()
14414 .delete(¶ms)
14415 .await;
14416 }
14417
14418 {
14419 let params: DocHeaderFootersPartsListBoundParams =
14420 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14421 let _ = DocApi::new(invoker)
14422 .header_footers()
14423 .parts()
14424 .list(¶ms)
14425 .await;
14426 }
14427
14428 {
14429 let params:DocHeaderFootersRefsClearBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"headerFooterSlot\",\"section\":{\"kind\":\"section\",\"sectionId\":\"\"},\"headerFooterKind\":\"header\",\"variant\":\"default\"}}").expect("generated inhabited parameter fixture");
14430 let _ = DocApi::new(invoker)
14431 .header_footers()
14432 .refs()
14433 .clear(¶ms)
14434 .await;
14435 }
14436
14437 {
14438 let params:DocHeaderFootersRefsSetBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"headerFooterSlot\",\"section\":{\"kind\":\"section\",\"sectionId\":\"\"},\"headerFooterKind\":\"header\",\"variant\":\"default\"},\"refId\":\"\"}").expect("generated inhabited parameter fixture");
14439 let _ = DocApi::new(invoker)
14440 .header_footers()
14441 .refs()
14442 .set(¶ms)
14443 .await;
14444 }
14445
14446 {
14447 let params:DocHeaderFootersRefsSetLinkedToPreviousBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"headerFooterSlot\",\"section\":{\"kind\":\"section\",\"sectionId\":\"\"},\"headerFooterKind\":\"header\",\"variant\":\"default\"},\"linked\":false}").expect("generated inhabited parameter fixture");
14448 let _ = DocApi::new(invoker)
14449 .header_footers()
14450 .refs()
14451 .set_linked_to_previous(¶ms)
14452 .await;
14453 }
14454
14455 {
14456 let params:DocHeaderFootersResolveBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"headerFooterSlot\",\"section\":{\"kind\":\"section\",\"sectionId\":\"\"},\"headerFooterKind\":\"header\",\"variant\":\"default\"}}").expect("generated inhabited parameter fixture");
14457 let _ = DocApi::new(invoker).header_footers().resolve(¶ms).await;
14458 }
14459
14460 {
14461 let params: DocHistoryGetBoundParams =
14462 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14463 let _ = DocApi::new(invoker).history().get(¶ms).await;
14464 }
14465
14466 {
14467 let params: DocHistoryRedoBoundParams =
14468 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14469 let _ = DocApi::new(invoker).history().redo(¶ms).await;
14470 }
14471
14472 {
14473 let params: DocHistoryUndoBoundParams =
14474 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14475 let _ = DocApi::new(invoker).history().undo(¶ms).await;
14476 }
14477
14478 {
14479 let params: DocHtmlToFragmentBoundParams =
14480 serde_json::from_str("{\"html\":\"\"}").expect("generated inhabited parameter fixture");
14481 let _ = DocApi::new(invoker).html_to_fragment(¶ms).await;
14482 }
14483
14484 {
14485 let params:DocHyperlinksGetBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"inline\",\"nodeType\":\"hyperlink\",\"anchor\":{\"start\":{\"blockId\":\"\",\"offset\":0},\"end\":{\"blockId\":\"\",\"offset\":0}}}}").expect("generated inhabited parameter fixture");
14486 let _ = DocApi::new(invoker).hyperlinks().get(¶ms).await;
14487 }
14488
14489 {
14490 let params: DocHyperlinksInsertBoundParams =
14491 serde_json::from_str("{\"text\":\"\",\"link\":{\"destination\":{}}}")
14492 .expect("generated inhabited parameter fixture");
14493 let _ = DocApi::new(invoker).hyperlinks().insert(¶ms).await;
14494 }
14495
14496 {
14497 let params: DocHyperlinksListBoundParams =
14498 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14499 let _ = DocApi::new(invoker).hyperlinks().list(¶ms).await;
14500 }
14501
14502 {
14503 let params:DocHyperlinksPatchBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"inline\",\"nodeType\":\"hyperlink\",\"anchor\":{\"start\":{\"blockId\":\"\",\"offset\":0},\"end\":{\"blockId\":\"\",\"offset\":0}}},\"patch\":{}}").expect("generated inhabited parameter fixture");
14504 let _ = DocApi::new(invoker).hyperlinks().patch(¶ms).await;
14505 }
14506
14507 {
14508 let params:DocHyperlinksRemoveBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"inline\",\"nodeType\":\"hyperlink\",\"anchor\":{\"start\":{\"blockId\":\"\",\"offset\":0},\"end\":{\"blockId\":\"\",\"offset\":0}}}}").expect("generated inhabited parameter fixture");
14509 let _ = DocApi::new(invoker).hyperlinks().remove(¶ms).await;
14510 }
14511
14512 {
14513 let params:DocHyperlinksWrapBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"text\",\"blockId\":\"\",\"range\":{\"start\":0,\"end\":0}},\"link\":{\"destination\":{}}}").expect("generated inhabited parameter fixture");
14514 let _ = DocApi::new(invoker).hyperlinks().wrap(¶ms).await;
14515 }
14516
14517 {
14518 let params: DocImagesConvertToFloatingBoundParams =
14519 serde_json::from_str("{\"imageId\":\"\"}")
14520 .expect("generated inhabited parameter fixture");
14521 let _ = DocApi::new(invoker)
14522 .images()
14523 .convert_to_floating(¶ms)
14524 .await;
14525 }
14526
14527 {
14528 let params: DocImagesConvertToInlineBoundParams =
14529 serde_json::from_str("{\"imageId\":\"\"}")
14530 .expect("generated inhabited parameter fixture");
14531 let _ = DocApi::new(invoker)
14532 .images()
14533 .convert_to_inline(¶ms)
14534 .await;
14535 }
14536
14537 {
14538 let params: DocImagesCropBoundParams =
14539 serde_json::from_str("{\"imageId\":\"\",\"crop\":{}}")
14540 .expect("generated inhabited parameter fixture");
14541 let _ = DocApi::new(invoker).images().crop(¶ms).await;
14542 }
14543
14544 {
14545 let params: DocImagesDeleteBoundParams = serde_json::from_str("{\"imageId\":\"\"}")
14546 .expect("generated inhabited parameter fixture");
14547 let _ = DocApi::new(invoker).images().delete(¶ms).await;
14548 }
14549
14550 {
14551 let params: DocImagesFlipBoundParams = serde_json::from_str("{\"imageId\":\"\"}")
14552 .expect("generated inhabited parameter fixture");
14553 let _ = DocApi::new(invoker).images().flip(¶ms).await;
14554 }
14555
14556 {
14557 let params: DocImagesGetBoundParams = serde_json::from_str("{\"imageId\":\"\"}")
14558 .expect("generated inhabited parameter fixture");
14559 let _ = DocApi::new(invoker).images().get(¶ms).await;
14560 }
14561
14562 {
14563 let params: DocImagesInsertCaptionBoundParams =
14564 serde_json::from_str("{\"imageId\":\"\",\"text\":\"\"}")
14565 .expect("generated inhabited parameter fixture");
14566 let _ = DocApi::new(invoker).images().insert_caption(¶ms).await;
14567 }
14568
14569 {
14570 let params: DocImagesListBoundParams =
14571 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14572 let _ = DocApi::new(invoker).images().list(¶ms).await;
14573 }
14574
14575 {
14576 let params: DocImagesMoveBoundParams =
14577 serde_json::from_str("{\"imageId\":\"\",\"to\":{\"kind\":\"documentStart\"}}")
14578 .expect("generated inhabited parameter fixture");
14579 let _ = DocApi::new(invoker).images().move_(¶ms).await;
14580 }
14581
14582 {
14583 let params: DocImagesRemoveCaptionBoundParams = serde_json::from_str("{\"imageId\":\"\"}")
14584 .expect("generated inhabited parameter fixture");
14585 let _ = DocApi::new(invoker).images().remove_caption(¶ms).await;
14586 }
14587
14588 {
14589 let params: DocImagesReplaceSourceBoundParams =
14590 serde_json::from_str("{\"imageId\":\"\",\"src\":\"\"}")
14591 .expect("generated inhabited parameter fixture");
14592 let _ = DocApi::new(invoker).images().replace_source(¶ms).await;
14593 }
14594
14595 {
14596 let params: DocImagesResetCropBoundParams = serde_json::from_str("{\"imageId\":\"\"}")
14597 .expect("generated inhabited parameter fixture");
14598 let _ = DocApi::new(invoker).images().reset_crop(¶ms).await;
14599 }
14600
14601 {
14602 let params: DocImagesRotateBoundParams =
14603 serde_json::from_str("{\"imageId\":\"\",\"angle\":0}")
14604 .expect("generated inhabited parameter fixture");
14605 let _ = DocApi::new(invoker).images().rotate(¶ms).await;
14606 }
14607
14608 {
14609 let params: DocImagesScaleBoundParams =
14610 serde_json::from_str("{\"imageId\":\"\",\"factor\":0}")
14611 .expect("generated inhabited parameter fixture");
14612 let _ = DocApi::new(invoker).images().scale(¶ms).await;
14613 }
14614
14615 {
14616 let params: DocImagesSetAltTextBoundParams =
14617 serde_json::from_str("{\"imageId\":\"\",\"description\":\"\"}")
14618 .expect("generated inhabited parameter fixture");
14619 let _ = DocApi::new(invoker).images().set_alt_text(¶ms).await;
14620 }
14621
14622 {
14623 let params: DocImagesSetAnchorOptionsBoundParams =
14624 serde_json::from_str("{\"imageId\":\"\",\"options\":{}}")
14625 .expect("generated inhabited parameter fixture");
14626 let _ = DocApi::new(invoker)
14627 .images()
14628 .set_anchor_options(¶ms)
14629 .await;
14630 }
14631
14632 {
14633 let params: DocImagesSetDecorativeBoundParams =
14634 serde_json::from_str("{\"imageId\":\"\",\"decorative\":false}")
14635 .expect("generated inhabited parameter fixture");
14636 let _ = DocApi::new(invoker).images().set_decorative(¶ms).await;
14637 }
14638
14639 {
14640 let params: DocImagesSetHyperlinkBoundParams =
14641 serde_json::from_str("{\"imageId\":\"\",\"url\":null}")
14642 .expect("generated inhabited parameter fixture");
14643 let _ = DocApi::new(invoker).images().set_hyperlink(¶ms).await;
14644 }
14645
14646 {
14647 let params: DocImagesSetLockAspectRatioBoundParams =
14648 serde_json::from_str("{\"imageId\":\"\",\"locked\":false}")
14649 .expect("generated inhabited parameter fixture");
14650 let _ = DocApi::new(invoker)
14651 .images()
14652 .set_lock_aspect_ratio(¶ms)
14653 .await;
14654 }
14655
14656 {
14657 let params: DocImagesSetNameBoundParams =
14658 serde_json::from_str("{\"imageId\":\"\",\"name\":\"\"}")
14659 .expect("generated inhabited parameter fixture");
14660 let _ = DocApi::new(invoker).images().set_name(¶ms).await;
14661 }
14662
14663 {
14664 let params: DocImagesSetPositionBoundParams =
14665 serde_json::from_str("{\"imageId\":\"\",\"position\":{}}")
14666 .expect("generated inhabited parameter fixture");
14667 let _ = DocApi::new(invoker).images().set_position(¶ms).await;
14668 }
14669
14670 {
14671 let params: DocImagesSetSizeBoundParams =
14672 serde_json::from_str("{\"imageId\":\"\",\"size\":{\"width\":0,\"height\":0}}")
14673 .expect("generated inhabited parameter fixture");
14674 let _ = DocApi::new(invoker).images().set_size(¶ms).await;
14675 }
14676
14677 {
14678 let params: DocImagesSetWrapDistancesBoundParams =
14679 serde_json::from_str("{\"imageId\":\"\",\"distances\":{}}")
14680 .expect("generated inhabited parameter fixture");
14681 let _ = DocApi::new(invoker)
14682 .images()
14683 .set_wrap_distances(¶ms)
14684 .await;
14685 }
14686
14687 {
14688 let params: DocImagesSetWrapSideBoundParams =
14689 serde_json::from_str("{\"imageId\":\"\",\"side\":\"bothSides\"}")
14690 .expect("generated inhabited parameter fixture");
14691 let _ = DocApi::new(invoker).images().set_wrap_side(¶ms).await;
14692 }
14693
14694 {
14695 let params: DocImagesSetWrapTypeBoundParams =
14696 serde_json::from_str("{\"imageId\":\"\",\"type\":\"None\"}")
14697 .expect("generated inhabited parameter fixture");
14698 let _ = DocApi::new(invoker).images().set_wrap_type(¶ms).await;
14699 }
14700
14701 {
14702 let params: DocImagesSetZOrderBoundParams =
14703 serde_json::from_str("{\"imageId\":\"\",\"zOrder\":{\"relativeHeight\":0}}")
14704 .expect("generated inhabited parameter fixture");
14705 let _ = DocApi::new(invoker).images().set_z_order(¶ms).await;
14706 }
14707
14708 {
14709 let params: DocImagesUpdateCaptionBoundParams =
14710 serde_json::from_str("{\"imageId\":\"\",\"text\":\"\"}")
14711 .expect("generated inhabited parameter fixture");
14712 let _ = DocApi::new(invoker).images().update_caption(¶ms).await;
14713 }
14714
14715 {
14716 let params: DocIndexConfigureBoundParams = serde_json::from_str(
14717 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"index\",\"nodeId\":\"\"},\"patch\":{}}",
14718 )
14719 .expect("generated inhabited parameter fixture");
14720 let _ = DocApi::new(invoker).index().configure(¶ms).await;
14721 }
14722
14723 {
14724 let params:DocIndexEntriesGetBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"inline\",\"nodeType\":\"indexEntry\",\"anchor\":{\"start\":{\"blockId\":\"\",\"offset\":0},\"end\":{\"blockId\":\"\",\"offset\":0}}}}").expect("generated inhabited parameter fixture");
14725 let _ = DocApi::new(invoker).index().entries().get(¶ms).await;
14726 }
14727
14728 {
14729 let params: DocIndexEntriesInsertBoundParams = serde_json::from_str(
14730 "{\"at\":{\"kind\":\"text\",\"segments\":[]},\"entry\":{\"text\":\"\"}}",
14731 )
14732 .expect("generated inhabited parameter fixture");
14733 let _ = DocApi::new(invoker).index().entries().insert(¶ms).await;
14734 }
14735
14736 {
14737 let params: DocIndexEntriesListBoundParams =
14738 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14739 let _ = DocApi::new(invoker).index().entries().list(¶ms).await;
14740 }
14741
14742 {
14743 let params:DocIndexEntriesRemoveBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"inline\",\"nodeType\":\"indexEntry\",\"anchor\":{\"start\":{\"blockId\":\"\",\"offset\":0},\"end\":{\"blockId\":\"\",\"offset\":0}}}}").expect("generated inhabited parameter fixture");
14744 let _ = DocApi::new(invoker).index().entries().remove(¶ms).await;
14745 }
14746
14747 {
14748 let params:DocIndexEntriesUpdateBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"inline\",\"nodeType\":\"indexEntry\",\"anchor\":{\"start\":{\"blockId\":\"\",\"offset\":0},\"end\":{\"blockId\":\"\",\"offset\":0}}},\"patch\":{}}").expect("generated inhabited parameter fixture");
14749 let _ = DocApi::new(invoker).index().entries().update(¶ms).await;
14750 }
14751
14752 {
14753 let params: DocIndexGetBoundParams = serde_json::from_str(
14754 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"index\",\"nodeId\":\"\"}}",
14755 )
14756 .expect("generated inhabited parameter fixture");
14757 let _ = DocApi::new(invoker).index().get(¶ms).await;
14758 }
14759
14760 {
14761 let params: DocIndexInsertBoundParams =
14762 serde_json::from_str("{\"at\":{\"kind\":\"documentStart\"}}")
14763 .expect("generated inhabited parameter fixture");
14764 let _ = DocApi::new(invoker).index().insert(¶ms).await;
14765 }
14766
14767 {
14768 let params: DocIndexListBoundParams =
14769 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14770 let _ = DocApi::new(invoker).index().list(¶ms).await;
14771 }
14772
14773 {
14774 let params: DocIndexRebuildBoundParams = serde_json::from_str(
14775 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"index\",\"nodeId\":\"\"}}",
14776 )
14777 .expect("generated inhabited parameter fixture");
14778 let _ = DocApi::new(invoker).index().rebuild(¶ms).await;
14779 }
14780
14781 {
14782 let params: DocIndexRemoveBoundParams = serde_json::from_str(
14783 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"index\",\"nodeId\":\"\"}}",
14784 )
14785 .expect("generated inhabited parameter fixture");
14786 let _ = DocApi::new(invoker).index().remove(¶ms).await;
14787 }
14788
14789 {
14790 let params: DocInfoBoundParams =
14791 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14792 let _ = DocApi::new(invoker).info(¶ms).await;
14793 }
14794
14795 {
14796 let params: DocInsertBoundParams =
14797 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14798 let _ = DocApi::new(invoker).insert(¶ms).await;
14799 }
14800
14801 {
14802 let params: DocInsertLineBreakBoundParams =
14803 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14804 let _ = DocApi::new(invoker).insert_line_break(¶ms).await;
14805 }
14806
14807 {
14808 let params: DocInsertTabBoundParams =
14809 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14810 let _ = DocApi::new(invoker).insert_tab(¶ms).await;
14811 }
14812
14813 {
14814 let params:DocListsApplyBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"paragraph\",\"nodeId\":\"\"},\"seed\":\"bullet\"}").expect("generated inhabited parameter fixture");
14815 let _ = DocApi::new(invoker).lists().apply(¶ms).await;
14816 }
14817
14818 {
14819 let params: DocListsApplyPresetBoundParams =
14820 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14821 let _ = DocApi::new(invoker).lists().apply_preset(¶ms).await;
14822 }
14823
14824 {
14825 let params:DocListsApplyStyleBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"listItem\",\"nodeId\":\"\"},\"style\":{\"version\":1,\"levels\":[]}}").expect("generated inhabited parameter fixture");
14826 let _ = DocApi::new(invoker).lists().apply_style(¶ms).await;
14827 }
14828
14829 {
14830 let params: DocListsApplyTemplateBoundParams =
14831 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14832 let _ = DocApi::new(invoker).lists().apply_template(¶ms).await;
14833 }
14834
14835 {
14836 let params: DocListsAttachBoundParams =
14837 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14838 let _ = DocApi::new(invoker).lists().attach(¶ms).await;
14839 }
14840
14841 {
14842 let params: DocListsCanContinuePreviousBoundParams =
14843 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14844 let _ = DocApi::new(invoker)
14845 .lists()
14846 .can_continue_previous(¶ms)
14847 .await;
14848 }
14849
14850 {
14851 let params: DocListsCanJoinBoundParams =
14852 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14853 let _ = DocApi::new(invoker).lists().can_join(¶ms).await;
14854 }
14855
14856 {
14857 let params: DocListsCaptureTemplateBoundParams =
14858 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14859 let _ = DocApi::new(invoker).lists().capture_template(¶ms).await;
14860 }
14861
14862 {
14863 let params: DocListsClearLevelOverridesBoundParams =
14864 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14865 let _ = DocApi::new(invoker)
14866 .lists()
14867 .clear_level_overrides(¶ms)
14868 .await;
14869 }
14870
14871 {
14872 let params: DocListsContinueBoundParams = serde_json::from_str(
14873 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"paragraph\",\"nodeId\":\"\"}}",
14874 )
14875 .expect("generated inhabited parameter fixture");
14876 let _ = DocApi::new(invoker).lists().continue_(¶ms).await;
14877 }
14878
14879 {
14880 let params: DocListsContinuePreviousBoundParams =
14881 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14882 let _ = DocApi::new(invoker)
14883 .lists()
14884 .continue_previous(¶ms)
14885 .await;
14886 }
14887
14888 {
14889 let params: DocListsConvertToTextBoundParams =
14890 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14891 let _ = DocApi::new(invoker).lists().convert_to_text(¶ms).await;
14892 }
14893
14894 {
14895 let params: DocListsCreateBoundParams =
14896 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14897 let _ = DocApi::new(invoker).lists().create(¶ms).await;
14898 }
14899
14900 {
14901 let params: DocListsDeleteBoundParams = serde_json::from_str(
14902 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"listItem\",\"nodeId\":\"\"}}",
14903 )
14904 .expect("generated inhabited parameter fixture");
14905 let _ = DocApi::new(invoker).lists().delete(¶ms).await;
14906 }
14907
14908 {
14909 let params: DocListsDetachBoundParams =
14910 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14911 let _ = DocApi::new(invoker).lists().detach(¶ms).await;
14912 }
14913
14914 {
14915 let params: DocListsGetBoundParams = serde_json::from_str(
14916 "{\"address\":{\"kind\":\"block\",\"nodeType\":\"listItem\",\"nodeId\":\"\"}}",
14917 )
14918 .expect("generated inhabited parameter fixture");
14919 let _ = DocApi::new(invoker).lists().get(¶ms).await;
14920 }
14921
14922 {
14923 let params: DocListsGetStateBoundParams = serde_json::from_str(
14924 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"paragraph\",\"nodeId\":\"\"}}",
14925 )
14926 .expect("generated inhabited parameter fixture");
14927 let _ = DocApi::new(invoker).lists().get_state(¶ms).await;
14928 }
14929
14930 {
14931 let params: DocListsGetStyleBoundParams = serde_json::from_str(
14932 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"listItem\",\"nodeId\":\"\"}}",
14933 )
14934 .expect("generated inhabited parameter fixture");
14935 let _ = DocApi::new(invoker).lists().get_style(¶ms).await;
14936 }
14937
14938 {
14939 let params: DocListsIndentBoundParams =
14940 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14941 let _ = DocApi::new(invoker).lists().indent(¶ms).await;
14942 }
14943
14944 {
14945 let params: DocListsInsertBoundParams =
14946 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14947 let _ = DocApi::new(invoker).lists().insert(¶ms).await;
14948 }
14949
14950 {
14951 let params: DocListsJoinBoundParams =
14952 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14953 let _ = DocApi::new(invoker).lists().join(¶ms).await;
14954 }
14955
14956 {
14957 let params: DocListsListBoundParams =
14958 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14959 let _ = DocApi::new(invoker).lists().list(¶ms).await;
14960 }
14961
14962 {
14963 let params:DocListsMergeBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"listItem\",\"nodeId\":\"\"},\"direction\":\"withPrevious\"}").expect("generated inhabited parameter fixture");
14964 let _ = DocApi::new(invoker).lists().merge(¶ms).await;
14965 }
14966
14967 {
14968 let params: DocListsOutdentBoundParams =
14969 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14970 let _ = DocApi::new(invoker).lists().outdent(¶ms).await;
14971 }
14972
14973 {
14974 let params: DocListsRemoveBoundParams = serde_json::from_str(
14975 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"paragraph\",\"nodeId\":\"\"}}",
14976 )
14977 .expect("generated inhabited parameter fixture");
14978 let _ = DocApi::new(invoker).lists().remove(¶ms).await;
14979 }
14980
14981 {
14982 let params: DocListsRestartBoundParams = serde_json::from_str(
14983 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"paragraph\",\"nodeId\":\"\"}}",
14984 )
14985 .expect("generated inhabited parameter fixture");
14986 let _ = DocApi::new(invoker).lists().restart(¶ms).await;
14987 }
14988
14989 {
14990 let params:DocListsRestartAtBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"listItem\",\"nodeId\":\"\"},\"startAt\":0}").expect("generated inhabited parameter fixture");
14991 let _ = DocApi::new(invoker).lists().restart_at(¶ms).await;
14992 }
14993
14994 {
14995 let params: DocListsSeparateBoundParams =
14996 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
14997 let _ = DocApi::new(invoker).lists().separate(¶ms).await;
14998 }
14999
15000 {
15001 let params: DocListsSetLevelBoundParams =
15002 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15003 let _ = DocApi::new(invoker).lists().set_level(¶ms).await;
15004 }
15005
15006 {
15007 let params: DocListsSetLevelAlignmentBoundParams =
15008 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15009 let _ = DocApi::new(invoker)
15010 .lists()
15011 .set_level_alignment(¶ms)
15012 .await;
15013 }
15014
15015 {
15016 let params: DocListsSetLevelBulletBoundParams =
15017 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15018 let _ = DocApi::new(invoker).lists().set_level_bullet(¶ms).await;
15019 }
15020
15021 {
15022 let params: DocListsSetLevelIndentsBoundParams =
15023 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15024 let _ = DocApi::new(invoker)
15025 .lists()
15026 .set_level_indents(¶ms)
15027 .await;
15028 }
15029
15030 {
15031 let params:DocListsSetLevelLayoutBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"listItem\",\"nodeId\":\"\"},\"level\":0,\"layout\":{}}").expect("generated inhabited parameter fixture");
15032 let _ = DocApi::new(invoker).lists().set_level_layout(¶ms).await;
15033 }
15034
15035 {
15036 let params: DocListsSetLevelMarkerFontBoundParams =
15037 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15038 let _ = DocApi::new(invoker)
15039 .lists()
15040 .set_level_marker_font(¶ms)
15041 .await;
15042 }
15043
15044 {
15045 let params: DocListsSetLevelNumberingBoundParams =
15046 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15047 let _ = DocApi::new(invoker)
15048 .lists()
15049 .set_level_numbering(¶ms)
15050 .await;
15051 }
15052
15053 {
15054 let params:DocListsSetLevelNumberStyleBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"listItem\",\"nodeId\":\"\"},\"level\":0,\"numberStyle\":\"\"}").expect("generated inhabited parameter fixture");
15055 let _ = DocApi::new(invoker)
15056 .lists()
15057 .set_level_number_style(¶ms)
15058 .await;
15059 }
15060
15061 {
15062 let params: DocListsSetLevelPictureBulletBoundParams =
15063 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15064 let _ = DocApi::new(invoker)
15065 .lists()
15066 .set_level_picture_bullet(¶ms)
15067 .await;
15068 }
15069
15070 {
15071 let params: DocListsSetLevelRestartBoundParams =
15072 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15073 let _ = DocApi::new(invoker)
15074 .lists()
15075 .set_level_restart(¶ms)
15076 .await;
15077 }
15078
15079 {
15080 let params:DocListsSetLevelStartBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"listItem\",\"nodeId\":\"\"},\"level\":0,\"startAt\":0}").expect("generated inhabited parameter fixture");
15081 let _ = DocApi::new(invoker).lists().set_level_start(¶ms).await;
15082 }
15083
15084 {
15085 let params:DocListsSetLevelTextBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"listItem\",\"nodeId\":\"\"},\"level\":0,\"text\":\"\"}").expect("generated inhabited parameter fixture");
15086 let _ = DocApi::new(invoker).lists().set_level_text(¶ms).await;
15087 }
15088
15089 {
15090 let params: DocListsSetLevelTrailingCharacterBoundParams =
15091 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15092 let _ = DocApi::new(invoker)
15093 .lists()
15094 .set_level_trailing_character(¶ms)
15095 .await;
15096 }
15097
15098 {
15099 let params:DocListsSetTypeBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"listItem\",\"nodeId\":\"\"},\"kind\":\"ordered\"}").expect("generated inhabited parameter fixture");
15100 let _ = DocApi::new(invoker).lists().set_type(¶ms).await;
15101 }
15102
15103 {
15104 let params: DocListsSetValueBoundParams =
15105 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15106 let _ = DocApi::new(invoker).lists().set_value(¶ms).await;
15107 }
15108
15109 {
15110 let params: DocListsSplitBoundParams = serde_json::from_str(
15111 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"listItem\",\"nodeId\":\"\"}}",
15112 )
15113 .expect("generated inhabited parameter fixture");
15114 let _ = DocApi::new(invoker).lists().split(¶ms).await;
15115 }
15116
15117 {
15118 let params: DocMarkdownToFragmentBoundParams = serde_json::from_str("{\"markdown\":\"\"}")
15119 .expect("generated inhabited parameter fixture");
15120 let _ = DocApi::new(invoker).markdown_to_fragment(¶ms).await;
15121 }
15122
15123 {
15124 let params:DocMetadataAttachBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"selection\",\"start\":{\"kind\":\"text\",\"blockId\":\"\",\"offset\":0},\"end\":{\"kind\":\"text\",\"blockId\":\"\",\"offset\":0}},\"namespace\":\"\",\"payload\":null}").expect("generated inhabited parameter fixture");
15125 let _ = DocApi::new(invoker).metadata().attach(¶ms).await;
15126 }
15127
15128 {
15129 let params: DocMetadataGetBoundParams =
15130 serde_json::from_str("{\"id\":\"\"}").expect("generated inhabited parameter fixture");
15131 let _ = DocApi::new(invoker).metadata().get(¶ms).await;
15132 }
15133
15134 {
15135 let params: DocMetadataListBoundParams =
15136 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15137 let _ = DocApi::new(invoker).metadata().list(¶ms).await;
15138 }
15139
15140 {
15141 let params: DocMetadataRemoveBoundParams =
15142 serde_json::from_str("{\"id\":\"\"}").expect("generated inhabited parameter fixture");
15143 let _ = DocApi::new(invoker).metadata().remove(¶ms).await;
15144 }
15145
15146 {
15147 let params: DocMetadataResolveBoundParams =
15148 serde_json::from_str("{\"id\":\"\"}").expect("generated inhabited parameter fixture");
15149 let _ = DocApi::new(invoker).metadata().resolve(¶ms).await;
15150 }
15151
15152 {
15153 let params: DocMetadataUpdateBoundParams =
15154 serde_json::from_str("{\"id\":\"\",\"payload\":null}")
15155 .expect("generated inhabited parameter fixture");
15156 let _ = DocApi::new(invoker).metadata().update(¶ms).await;
15157 }
15158
15159 {
15160 let params: DocMutationsApplyBoundParams =
15161 serde_json::from_str("{\"atomic\":false,\"steps\":[]}")
15162 .expect("generated inhabited parameter fixture");
15163 let _ = DocApi::new(invoker).mutations().apply(¶ms).await;
15164 }
15165
15166 {
15167 let params: DocMutationsBeginTemporaryBoundParams =
15168 serde_json::from_str("{\"tag\":\"\",\"operations\":[]}")
15169 .expect("generated inhabited parameter fixture");
15170 let _ = DocApi::new(invoker)
15171 .mutations()
15172 .begin_temporary(¶ms)
15173 .await;
15174 }
15175
15176 {
15177 let params: DocMutationsCommitTemporaryBoundParams =
15178 serde_json::from_str("{\"previewId\":\"\"}")
15179 .expect("generated inhabited parameter fixture");
15180 let _ = DocApi::new(invoker)
15181 .mutations()
15182 .commit_temporary(¶ms)
15183 .await;
15184 }
15185
15186 {
15187 let params: DocMutationsPreviewBoundParams =
15188 serde_json::from_str("{\"atomic\":false,\"changeMode\":\"direct\",\"steps\":[]}")
15189 .expect("generated inhabited parameter fixture");
15190 let _ = DocApi::new(invoker).mutations().preview(¶ms).await;
15191 }
15192
15193 {
15194 let params: DocMutationsReplaceTemporaryBoundParams =
15195 serde_json::from_str("{\"tag\":\"\",\"operations\":[],\"previewId\":\"\"}")
15196 .expect("generated inhabited parameter fixture");
15197 let _ = DocApi::new(invoker)
15198 .mutations()
15199 .replace_temporary(¶ms)
15200 .await;
15201 }
15202
15203 {
15204 let params: DocMutationsRollbackTemporaryBoundParams =
15205 serde_json::from_str("{\"previewId\":\"\"}")
15206 .expect("generated inhabited parameter fixture");
15207 let _ = DocApi::new(invoker)
15208 .mutations()
15209 .rollback_temporary(¶ms)
15210 .await;
15211 }
15212
15213 {
15214 let params: DocOpenParams =
15215 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15216 let _ = ClientApi::new(invoker).open(¶ms).await;
15217 }
15218
15219 {
15220 let params:DocPermissionRangesCreateBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"selection\",\"start\":{\"kind\":\"text\",\"blockId\":\"\",\"offset\":0},\"end\":{\"kind\":\"text\",\"blockId\":\"\",\"offset\":0}},\"principal\":{\"kind\":\"everyone\"}}").expect("generated inhabited parameter fixture");
15221 let _ = DocApi::new(invoker)
15222 .permission_ranges()
15223 .create(¶ms)
15224 .await;
15225 }
15226
15227 {
15228 let params: DocPermissionRangesGetBoundParams =
15229 serde_json::from_str("{\"id\":\"\"}").expect("generated inhabited parameter fixture");
15230 let _ = DocApi::new(invoker).permission_ranges().get(¶ms).await;
15231 }
15232
15233 {
15234 let params: DocPermissionRangesListBoundParams =
15235 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15236 let _ = DocApi::new(invoker).permission_ranges().list(¶ms).await;
15237 }
15238
15239 {
15240 let params: DocPermissionRangesRemoveBoundParams =
15241 serde_json::from_str("{\"id\":\"\"}").expect("generated inhabited parameter fixture");
15242 let _ = DocApi::new(invoker)
15243 .permission_ranges()
15244 .remove(¶ms)
15245 .await;
15246 }
15247
15248 {
15249 let params: DocPermissionRangesUpdatePrincipalBoundParams =
15250 serde_json::from_str("{\"id\":\"\",\"principal\":{\"kind\":\"everyone\"}}")
15251 .expect("generated inhabited parameter fixture");
15252 let _ = DocApi::new(invoker)
15253 .permission_ranges()
15254 .update_principal(¶ms)
15255 .await;
15256 }
15257
15258 {
15259 let params: DocPlanExecuteBoundParams = serde_json::from_str("{\"entries\":[]}")
15260 .expect("generated inhabited parameter fixture");
15261 let _ = DocApi::new(invoker).plan().execute(¶ms).await;
15262 }
15263
15264 {
15265 let params: DocPresetDispatchBoundParams = serde_json::from_str("{\"toolName\":\"\"}")
15266 .expect("generated inhabited parameter fixture");
15267 let _ = DocApi::new(invoker).preset().dispatch(¶ms).await;
15268 }
15269
15270 {
15271 let params: DocPresetGetCatalogBoundParams =
15272 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15273 let _ = DocApi::new(invoker).preset().get_catalog(¶ms).await;
15274 }
15275
15276 {
15277 let params: DocPresetGetMcpPromptBoundParams =
15278 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15279 let _ = DocApi::new(invoker).preset().get_mcp_prompt(¶ms).await;
15280 }
15281
15282 {
15283 let params: DocPresetGetSystemPromptBoundParams =
15284 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15285 let _ = DocApi::new(invoker)
15286 .preset()
15287 .get_system_prompt(¶ms)
15288 .await;
15289 }
15290
15291 {
15292 let params: DocPresetGetToolsBoundParams =
15293 serde_json::from_str("{\"provider\":\"openai\"}")
15294 .expect("generated inhabited parameter fixture");
15295 let _ = DocApi::new(invoker).preset().get_tools(¶ms).await;
15296 }
15297
15298 {
15299 let params: DocPresetListBoundParams =
15300 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15301 let _ = DocApi::new(invoker).preset().list(¶ms).await;
15302 }
15303
15304 {
15305 let params: DocProjectHtmlBoundParams =
15306 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15307 let _ = DocApi::new(invoker).project_html(¶ms).await;
15308 }
15309
15310 {
15311 let params: DocProjectMarkdownBoundParams =
15312 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15313 let _ = DocApi::new(invoker).project_markdown(¶ms).await;
15314 }
15315
15316 {
15317 let params: DocProtectionClearEditingRestrictionBoundParams =
15318 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15319 let _ = DocApi::new(invoker)
15320 .protection()
15321 .clear_editing_restriction(¶ms)
15322 .await;
15323 }
15324
15325 {
15326 let params: DocProtectionGetBoundParams =
15327 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15328 let _ = DocApi::new(invoker).protection().get(¶ms).await;
15329 }
15330
15331 {
15332 let params: DocProtectionSetEditingRestrictionBoundParams =
15333 serde_json::from_str("{\"mode\":\"readOnly\"}")
15334 .expect("generated inhabited parameter fixture");
15335 let _ = DocApi::new(invoker)
15336 .protection()
15337 .set_editing_restriction(¶ms)
15338 .await;
15339 }
15340
15341 {
15342 let params: DocQueryMatchBoundParams =
15343 serde_json::from_str("{\"select\":{\"type\":\"text\",\"pattern\":\"\"}}")
15344 .expect("generated inhabited parameter fixture");
15345 let _ = DocApi::new(invoker).query().match_(¶ms).await;
15346 }
15347
15348 {
15349 let params:DocRangesResolveBoundParams=serde_json::from_str("{\"start\":{\"kind\":\"document\",\"edge\":\"start\"},\"end\":{\"kind\":\"document\",\"edge\":\"start\"}}").expect("generated inhabited parameter fixture");
15350 let _ = DocApi::new(invoker).ranges().resolve(¶ms).await;
15351 }
15352
15353 {
15354 let params: DocReplaceBoundParams =
15355 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15356 let _ = DocApi::new(invoker).replace(¶ms).await;
15357 }
15358
15359 {
15360 let params: DocSaveBoundParams =
15361 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15362 let _ = DocApi::new(invoker).save(¶ms).await;
15363 }
15364
15365 {
15366 let params:DocSectionsClearHeaderFooterRefBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"section\",\"sectionId\":\"\"},\"kind\":\"header\",\"variant\":\"default\"}").expect("generated inhabited parameter fixture");
15367 let _ = DocApi::new(invoker)
15368 .sections()
15369 .clear_header_footer_ref(¶ms)
15370 .await;
15371 }
15372
15373 {
15374 let params: DocSectionsClearPageBordersBoundParams =
15375 serde_json::from_str("{\"target\":{\"kind\":\"section\",\"sectionId\":\"\"}}")
15376 .expect("generated inhabited parameter fixture");
15377 let _ = DocApi::new(invoker)
15378 .sections()
15379 .clear_page_borders(¶ms)
15380 .await;
15381 }
15382
15383 {
15384 let params: DocSectionsGetBoundParams =
15385 serde_json::from_str("{\"address\":{\"kind\":\"section\",\"sectionId\":\"\"}}")
15386 .expect("generated inhabited parameter fixture");
15387 let _ = DocApi::new(invoker).sections().get(¶ms).await;
15388 }
15389
15390 {
15391 let params: DocSectionsListBoundParams =
15392 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15393 let _ = DocApi::new(invoker).sections().list(¶ms).await;
15394 }
15395
15396 {
15397 let params: DocSectionsSetBreakTypeBoundParams = serde_json::from_str(
15398 "{\"target\":{\"kind\":\"section\",\"sectionId\":\"\"},\"breakType\":\"continuous\"}",
15399 )
15400 .expect("generated inhabited parameter fixture");
15401 let _ = DocApi::new(invoker)
15402 .sections()
15403 .set_break_type(¶ms)
15404 .await;
15405 }
15406
15407 {
15408 let params: DocSectionsSetColumnsBoundParams =
15409 serde_json::from_str("{\"target\":{\"kind\":\"section\",\"sectionId\":\"\"}}")
15410 .expect("generated inhabited parameter fixture");
15411 let _ = DocApi::new(invoker).sections().set_columns(¶ms).await;
15412 }
15413
15414 {
15415 let params: DocSectionsSetHeaderFooterMarginsBoundParams =
15416 serde_json::from_str("{\"target\":{\"kind\":\"section\",\"sectionId\":\"\"}}")
15417 .expect("generated inhabited parameter fixture");
15418 let _ = DocApi::new(invoker)
15419 .sections()
15420 .set_header_footer_margins(¶ms)
15421 .await;
15422 }
15423
15424 {
15425 let params:DocSectionsSetHeaderFooterRefBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"section\",\"sectionId\":\"\"},\"kind\":\"header\",\"variant\":\"default\",\"refId\":\"\"}").expect("generated inhabited parameter fixture");
15426 let _ = DocApi::new(invoker)
15427 .sections()
15428 .set_header_footer_ref(¶ms)
15429 .await;
15430 }
15431
15432 {
15433 let params: DocSectionsSetLineNumberingBoundParams = serde_json::from_str(
15434 "{\"target\":{\"kind\":\"section\",\"sectionId\":\"\"},\"enabled\":false}",
15435 )
15436 .expect("generated inhabited parameter fixture");
15437 let _ = DocApi::new(invoker)
15438 .sections()
15439 .set_line_numbering(¶ms)
15440 .await;
15441 }
15442
15443 {
15444 let params:DocSectionsSetLinkToPreviousBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"section\",\"sectionId\":\"\"},\"kind\":\"header\",\"variant\":\"default\",\"linked\":false}").expect("generated inhabited parameter fixture");
15445 let _ = DocApi::new(invoker)
15446 .sections()
15447 .set_link_to_previous(¶ms)
15448 .await;
15449 }
15450
15451 {
15452 let params: DocSectionsSetOddEvenHeadersFootersBoundParams =
15453 serde_json::from_str("{\"enabled\":false}")
15454 .expect("generated inhabited parameter fixture");
15455 let _ = DocApi::new(invoker)
15456 .sections()
15457 .set_odd_even_headers_footers(¶ms)
15458 .await;
15459 }
15460
15461 {
15462 let params: DocSectionsSetPageBordersBoundParams = serde_json::from_str(
15463 "{\"target\":{\"kind\":\"section\",\"sectionId\":\"\"},\"borders\":null}",
15464 )
15465 .expect("generated inhabited parameter fixture");
15466 let _ = DocApi::new(invoker)
15467 .sections()
15468 .set_page_borders(¶ms)
15469 .await;
15470 }
15471
15472 {
15473 let params: DocSectionsSetPageMarginsBoundParams =
15474 serde_json::from_str("{\"target\":{\"kind\":\"section\",\"sectionId\":\"\"}}")
15475 .expect("generated inhabited parameter fixture");
15476 let _ = DocApi::new(invoker)
15477 .sections()
15478 .set_page_margins(¶ms)
15479 .await;
15480 }
15481
15482 {
15483 let params: DocSectionsSetPageNumberingBoundParams =
15484 serde_json::from_str("{\"target\":{\"kind\":\"section\",\"sectionId\":\"\"}}")
15485 .expect("generated inhabited parameter fixture");
15486 let _ = DocApi::new(invoker)
15487 .sections()
15488 .set_page_numbering(¶ms)
15489 .await;
15490 }
15491
15492 {
15493 let params: DocSectionsSetPageSetupBoundParams =
15494 serde_json::from_str("{\"target\":{\"kind\":\"section\",\"sectionId\":\"\"}}")
15495 .expect("generated inhabited parameter fixture");
15496 let _ = DocApi::new(invoker)
15497 .sections()
15498 .set_page_setup(¶ms)
15499 .await;
15500 }
15501
15502 {
15503 let params: DocSectionsSetSectionDirectionBoundParams = serde_json::from_str(
15504 "{\"target\":{\"kind\":\"section\",\"sectionId\":\"\"},\"direction\":\"ltr\"}",
15505 )
15506 .expect("generated inhabited parameter fixture");
15507 let _ = DocApi::new(invoker)
15508 .sections()
15509 .set_section_direction(¶ms)
15510 .await;
15511 }
15512
15513 {
15514 let params: DocSectionsSetTitlePageBoundParams = serde_json::from_str(
15515 "{\"target\":{\"kind\":\"section\",\"sectionId\":\"\"},\"enabled\":false}",
15516 )
15517 .expect("generated inhabited parameter fixture");
15518 let _ = DocApi::new(invoker)
15519 .sections()
15520 .set_title_page(¶ms)
15521 .await;
15522 }
15523
15524 {
15525 let params: DocSectionsSetVerticalAlignBoundParams = serde_json::from_str(
15526 "{\"target\":{\"kind\":\"section\",\"sectionId\":\"\"},\"value\":\"top\"}",
15527 )
15528 .expect("generated inhabited parameter fixture");
15529 let _ = DocApi::new(invoker)
15530 .sections()
15531 .set_vertical_align(¶ms)
15532 .await;
15533 }
15534
15535 {
15536 let params: DocSelectionCurrentBoundParams =
15537 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15538 let _ = DocApi::new(invoker).selection().current(¶ms).await;
15539 }
15540
15541 {
15542 let params: DocSelectionExtractOoxmlBoundParams =
15543 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15544 let _ = DocApi::new(invoker)
15545 .selection()
15546 .extract_ooxml(¶ms)
15547 .await;
15548 }
15549
15550 {
15551 let params: DocSelectionReleaseSnapshotBoundParams =
15552 serde_json::from_str("{\"snapshotId\":\"\"}")
15553 .expect("generated inhabited parameter fixture");
15554 let _ = DocApi::new(invoker)
15555 .selection()
15556 .release_snapshot(¶ms)
15557 .await;
15558 }
15559
15560 {
15561 let params: DocSessionCloseParams = serde_json::from_str("{\"sessionId\":\"\"}")
15562 .expect("generated inhabited parameter fixture");
15563 let _ = InternalApi::new(invoker).session().close(¶ms).await;
15564 }
15565
15566 {
15567 let params: DocSessionListParams =
15568 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15569 let _ = InternalApi::new(invoker).session().list(¶ms).await;
15570 }
15571
15572 {
15573 let params: DocSessionSaveParams = serde_json::from_str("{\"sessionId\":\"\"}")
15574 .expect("generated inhabited parameter fixture");
15575 let _ = InternalApi::new(invoker).session().save(¶ms).await;
15576 }
15577
15578 {
15579 let params: DocSessionSetDefaultParams = serde_json::from_str("{\"sessionId\":\"\"}")
15580 .expect("generated inhabited parameter fixture");
15581 let _ = InternalApi::new(invoker)
15582 .session()
15583 .set_default(¶ms)
15584 .await;
15585 }
15586
15587 {
15588 let params: DocStatusParams =
15589 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15590 let _ = InternalApi::new(invoker).status(¶ms).await;
15591 }
15592
15593 {
15594 let params: DocStylesApplyBoundParams =
15595 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15596 let _ = DocApi::new(invoker).styles().apply(¶ms).await;
15597 }
15598
15599 {
15600 let params: DocStylesCreateBoundParams =
15601 serde_json::from_str("{\"id\":\"\",\"name\":\"\",\"type\":\"paragraph\"}")
15602 .expect("generated inhabited parameter fixture");
15603 let _ = DocApi::new(invoker).styles().create(¶ms).await;
15604 }
15605
15606 {
15607 let params: DocStylesGetCatalogBoundParams =
15608 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15609 let _ = DocApi::new(invoker).styles().get_catalog(¶ms).await;
15610 }
15611
15612 {
15613 let params: DocStylesGetThemeBoundParams =
15614 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15615 let _ = DocApi::new(invoker).styles().get_theme(¶ms).await;
15616 }
15617
15618 {
15619 let params: DocStylesParagraphClearStyleBoundParams = serde_json::from_str(
15620 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"paragraph\",\"nodeId\":\"\"}}",
15621 )
15622 .expect("generated inhabited parameter fixture");
15623 let _ = DocApi::new(invoker)
15624 .styles()
15625 .paragraph()
15626 .clear_style(¶ms)
15627 .await;
15628 }
15629
15630 {
15631 let params: DocStylesParagraphSetStyleBoundParams = serde_json::from_str(
15632 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"paragraph\",\"nodeId\":\"\"}}",
15633 )
15634 .expect("generated inhabited parameter fixture");
15635 let _ = DocApi::new(invoker)
15636 .styles()
15637 .paragraph()
15638 .set_style(¶ms)
15639 .await;
15640 }
15641
15642 {
15643 let params:DocStylesParagraphSetStyleRefBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"paragraph\",\"nodeId\":\"\"},\"styleId\":\"\"}").expect("generated inhabited parameter fixture");
15644 let _ = DocApi::new(invoker)
15645 .styles()
15646 .paragraph()
15647 .set_style_ref(¶ms)
15648 .await;
15649 }
15650
15651 {
15652 let params: DocTablesApplyBorderPresetBoundParams =
15653 serde_json::from_str("{\"preset\":\"box\"}")
15654 .expect("generated inhabited parameter fixture");
15655 let _ = DocApi::new(invoker)
15656 .tables()
15657 .apply_border_preset(¶ms)
15658 .await;
15659 }
15660
15661 {
15662 let params: DocTablesApplyPresetBoundParams = serde_json::from_str("{\"preset\":\"grid\"}")
15663 .expect("generated inhabited parameter fixture");
15664 let _ = DocApi::new(invoker).tables().apply_preset(¶ms).await;
15665 }
15666
15667 {
15668 let params: DocTablesApplyStyleBoundParams =
15669 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15670 let _ = DocApi::new(invoker).tables().apply_style(¶ms).await;
15671 }
15672
15673 {
15674 let params: DocTablesClearBorderBoundParams = serde_json::from_str("{\"edge\":\"top\"}")
15675 .expect("generated inhabited parameter fixture");
15676 let _ = DocApi::new(invoker).tables().clear_border(¶ms).await;
15677 }
15678
15679 {
15680 let params: DocTablesClearCellSpacingBoundParams =
15681 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15682 let _ = DocApi::new(invoker)
15683 .tables()
15684 .clear_cell_spacing(¶ms)
15685 .await;
15686 }
15687
15688 {
15689 let params: DocTablesClearContentsBoundParams =
15690 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15691 let _ = DocApi::new(invoker).tables().clear_contents(¶ms).await;
15692 }
15693
15694 {
15695 let params: DocTablesClearDefaultStyleBoundParams =
15696 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15697 let _ = DocApi::new(invoker)
15698 .tables()
15699 .clear_default_style(¶ms)
15700 .await;
15701 }
15702
15703 {
15704 let params: DocTablesClearShadingBoundParams =
15705 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15706 let _ = DocApi::new(invoker).tables().clear_shading(¶ms).await;
15707 }
15708
15709 {
15710 let params: DocTablesClearStyleBoundParams =
15711 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15712 let _ = DocApi::new(invoker).tables().clear_style(¶ms).await;
15713 }
15714
15715 {
15716 let params: DocTablesConvertFromTextBoundParams =
15717 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15718 let _ = DocApi::new(invoker)
15719 .tables()
15720 .convert_from_text(¶ms)
15721 .await;
15722 }
15723
15724 {
15725 let params: DocTablesConvertToTextBoundParams =
15726 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15727 let _ = DocApi::new(invoker).tables().convert_to_text(¶ms).await;
15728 }
15729
15730 {
15731 let params: DocTablesDeleteBoundParams =
15732 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15733 let _ = DocApi::new(invoker).tables().delete(¶ms).await;
15734 }
15735
15736 {
15737 let params: DocTablesDeleteCellBoundParams =
15738 serde_json::from_str("{\"mode\":\"shiftLeft\"}")
15739 .expect("generated inhabited parameter fixture");
15740 let _ = DocApi::new(invoker).tables().delete_cell(¶ms).await;
15741 }
15742
15743 {
15744 let params: DocTablesDeleteColumnBoundParams = serde_json::from_str("{\"columnIndex\":0}")
15745 .expect("generated inhabited parameter fixture");
15746 let _ = DocApi::new(invoker).tables().delete_column(¶ms).await;
15747 }
15748
15749 {
15750 let params: DocTablesDeleteRowBoundParams =
15751 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15752 let _ = DocApi::new(invoker).tables().delete_row(¶ms).await;
15753 }
15754
15755 {
15756 let params: DocTablesDistributeColumnsBoundParams =
15757 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15758 let _ = DocApi::new(invoker)
15759 .tables()
15760 .distribute_columns(¶ms)
15761 .await;
15762 }
15763
15764 {
15765 let params: DocTablesDistributeRowsBoundParams =
15766 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15767 let _ = DocApi::new(invoker).tables().distribute_rows(¶ms).await;
15768 }
15769
15770 {
15771 let params: DocTablesGetBoundParams =
15772 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15773 let _ = DocApi::new(invoker).tables().get(¶ms).await;
15774 }
15775
15776 {
15777 let params: DocTablesGetCellsBoundParams =
15778 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15779 let _ = DocApi::new(invoker).tables().get_cells(¶ms).await;
15780 }
15781
15782 {
15783 let params: DocTablesGetPropertiesBoundParams =
15784 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15785 let _ = DocApi::new(invoker).tables().get_properties(¶ms).await;
15786 }
15787
15788 {
15789 let params: DocTablesGetStylesBoundParams =
15790 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15791 let _ = DocApi::new(invoker).tables().get_styles(¶ms).await;
15792 }
15793
15794 {
15795 let params: DocTablesInsertCellBoundParams =
15796 serde_json::from_str("{\"mode\":\"shiftRight\"}")
15797 .expect("generated inhabited parameter fixture");
15798 let _ = DocApi::new(invoker).tables().insert_cell(¶ms).await;
15799 }
15800
15801 {
15802 let params: DocTablesInsertColumnBoundParams =
15803 serde_json::from_str("{\"position\":\"left\"}")
15804 .expect("generated inhabited parameter fixture");
15805 let _ = DocApi::new(invoker).tables().insert_column(¶ms).await;
15806 }
15807
15808 {
15809 let params: DocTablesInsertRowBoundParams =
15810 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15811 let _ = DocApi::new(invoker).tables().insert_row(¶ms).await;
15812 }
15813
15814 {
15815 let params:DocTablesMergeCellsBoundParams=serde_json::from_str("{\"start\":{\"rowIndex\":0,\"columnIndex\":0},\"end\":{\"rowIndex\":0,\"columnIndex\":0}}").expect("generated inhabited parameter fixture");
15816 let _ = DocApi::new(invoker).tables().merge_cells(¶ms).await;
15817 }
15818
15819 {
15820 let params: DocTablesMoveBoundParams =
15821 serde_json::from_str("{\"destination\":{\"kind\":\"documentStart\"}}")
15822 .expect("generated inhabited parameter fixture");
15823 let _ = DocApi::new(invoker).tables().move_(¶ms).await;
15824 }
15825
15826 {
15827 let params: DocTablesMoveColumnBoundParams =
15828 serde_json::from_str("{\"columnIndex\":0,\"destination\":{\"kind\":\"first\"}}")
15829 .expect("generated inhabited parameter fixture");
15830 let _ = DocApi::new(invoker).tables().move_column(¶ms).await;
15831 }
15832
15833 {
15834 let params: DocTablesMoveRowBoundParams =
15835 serde_json::from_str("{\"destination\":{\"kind\":\"first\"}}")
15836 .expect("generated inhabited parameter fixture");
15837 let _ = DocApi::new(invoker).tables().move_row(¶ms).await;
15838 }
15839
15840 {
15841 let params: DocTablesSetAltTextBoundParams =
15842 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15843 let _ = DocApi::new(invoker).tables().set_alt_text(¶ms).await;
15844 }
15845
15846 {
15847 let params: DocTablesSetBorderBoundParams = serde_json::from_str(
15848 "{\"edge\":\"top\",\"lineStyle\":\"\",\"lineWeightPt\":0,\"color\":\"\"}",
15849 )
15850 .expect("generated inhabited parameter fixture");
15851 let _ = DocApi::new(invoker).tables().set_border(¶ms).await;
15852 }
15853
15854 {
15855 let params: DocTablesSetBordersBoundParams = serde_json::from_str("{\"mode\":\"applyTo\"}")
15856 .expect("generated inhabited parameter fixture");
15857 let _ = DocApi::new(invoker).tables().set_borders(¶ms).await;
15858 }
15859
15860 {
15861 let params: DocTablesSetCellPaddingBoundParams =
15862 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15863 let _ = DocApi::new(invoker)
15864 .tables()
15865 .set_cell_padding(¶ms)
15866 .await;
15867 }
15868
15869 {
15870 let params: DocTablesSetCellPropertiesBoundParams =
15871 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15872 let _ = DocApi::new(invoker)
15873 .tables()
15874 .set_cell_properties(¶ms)
15875 .await;
15876 }
15877
15878 {
15879 let params: DocTablesSetCellSpacingBoundParams = serde_json::from_str("{\"spacingPt\":0}")
15880 .expect("generated inhabited parameter fixture");
15881 let _ = DocApi::new(invoker)
15882 .tables()
15883 .set_cell_spacing(¶ms)
15884 .await;
15885 }
15886
15887 {
15888 let params: DocTablesSetCellTextBoundParams =
15889 serde_json::from_str("{\"text\":\"\"}").expect("generated inhabited parameter fixture");
15890 let _ = DocApi::new(invoker).tables().set_cell_text(¶ms).await;
15891 }
15892
15893 {
15894 let params: DocTablesSetColumnWidthBoundParams =
15895 serde_json::from_str("{\"columnIndex\":0,\"widthPt\":0}")
15896 .expect("generated inhabited parameter fixture");
15897 let _ = DocApi::new(invoker)
15898 .tables()
15899 .set_column_width(¶ms)
15900 .await;
15901 }
15902
15903 {
15904 let params: DocTablesSetDefaultStyleBoundParams =
15905 serde_json::from_str("{\"styleId\":\"\"}")
15906 .expect("generated inhabited parameter fixture");
15907 let _ = DocApi::new(invoker)
15908 .tables()
15909 .set_default_style(¶ms)
15910 .await;
15911 }
15912
15913 {
15914 let params: DocTablesSetLayoutBoundParams =
15915 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15916 let _ = DocApi::new(invoker).tables().set_layout(¶ms).await;
15917 }
15918
15919 {
15920 let params: DocTablesSetRowHeightBoundParams = serde_json::from_str("{\"heightPt\":0}")
15921 .expect("generated inhabited parameter fixture");
15922 let _ = DocApi::new(invoker).tables().set_row_height(¶ms).await;
15923 }
15924
15925 {
15926 let params: DocTablesSetRowOptionsBoundParams =
15927 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15928 let _ = DocApi::new(invoker).tables().set_row_options(¶ms).await;
15929 }
15930
15931 {
15932 let params: DocTablesSetShadingBoundParams = serde_json::from_str("{\"color\":\"\"}")
15933 .expect("generated inhabited parameter fixture");
15934 let _ = DocApi::new(invoker).tables().set_shading(¶ms).await;
15935 }
15936
15937 {
15938 let params: DocTablesSetStyleBoundParams =
15939 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15940 let _ = DocApi::new(invoker).tables().set_style(¶ms).await;
15941 }
15942
15943 {
15944 let params: DocTablesSetStyleOptionBoundParams =
15945 serde_json::from_str("{\"flag\":\"headerRow\",\"enabled\":false}")
15946 .expect("generated inhabited parameter fixture");
15947 let _ = DocApi::new(invoker)
15948 .tables()
15949 .set_style_option(¶ms)
15950 .await;
15951 }
15952
15953 {
15954 let params: DocTablesSetTableOptionsBoundParams =
15955 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15956 let _ = DocApi::new(invoker)
15957 .tables()
15958 .set_table_options(¶ms)
15959 .await;
15960 }
15961
15962 {
15963 let params: DocTablesSetTablePaddingBoundParams =
15964 serde_json::from_str("{\"topPt\":0,\"rightPt\":0,\"bottomPt\":0,\"leftPt\":0}")
15965 .expect("generated inhabited parameter fixture");
15966 let _ = DocApi::new(invoker)
15967 .tables()
15968 .set_table_padding(¶ms)
15969 .await;
15970 }
15971
15972 {
15973 let params: DocTablesSortBoundParams =
15974 serde_json::from_str("{\"keys\":[]}").expect("generated inhabited parameter fixture");
15975 let _ = DocApi::new(invoker).tables().sort(¶ms).await;
15976 }
15977
15978 {
15979 let params: DocTablesSplitBoundParams = serde_json::from_str("{\"rowIndex\":0}")
15980 .expect("generated inhabited parameter fixture");
15981 let _ = DocApi::new(invoker).tables().split(¶ms).await;
15982 }
15983
15984 {
15985 let params: DocTablesSplitCellBoundParams =
15986 serde_json::from_str("{\"rows\":0,\"columns\":0}")
15987 .expect("generated inhabited parameter fixture");
15988 let _ = DocApi::new(invoker).tables().split_cell(¶ms).await;
15989 }
15990
15991 {
15992 let params: DocTablesUnmergeCellsBoundParams =
15993 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
15994 let _ = DocApi::new(invoker).tables().unmerge_cells(¶ms).await;
15995 }
15996
15997 {
15998 let params: DocTemplatesApplyBoundParams =
15999 serde_json::from_str("{\"source\":{\"kind\":\"path\",\"path\":\"\"}}")
16000 .expect("generated inhabited parameter fixture");
16001 let _ = DocApi::new(invoker).templates().apply(¶ms).await;
16002 }
16003
16004 {
16005 let params:DocTocConfigureBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"tableOfContents\",\"nodeId\":\"\"},\"patch\":{}}").expect("generated inhabited parameter fixture");
16006 let _ = DocApi::new(invoker).toc().configure(¶ms).await;
16007 }
16008
16009 {
16010 let params:DocTocEditEntryBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"inline\",\"nodeType\":\"tableOfContentsEntry\",\"nodeId\":\"\"},\"patch\":{}}").expect("generated inhabited parameter fixture");
16011 let _ = DocApi::new(invoker).toc().edit_entry(¶ms).await;
16012 }
16013
16014 {
16015 let params: DocTocGetBoundParams = serde_json::from_str(
16016 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"tableOfContents\",\"nodeId\":\"\"}}",
16017 )
16018 .expect("generated inhabited parameter fixture");
16019 let _ = DocApi::new(invoker).toc().get(¶ms).await;
16020 }
16021
16022 {
16023 let params:DocTocGetEntryBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"inline\",\"nodeType\":\"tableOfContentsEntry\",\"nodeId\":\"\"}}").expect("generated inhabited parameter fixture");
16024 let _ = DocApi::new(invoker).toc().get_entry(¶ms).await;
16025 }
16026
16027 {
16028 let params: DocTocListBoundParams =
16029 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
16030 let _ = DocApi::new(invoker).toc().list(¶ms).await;
16031 }
16032
16033 {
16034 let params: DocTocListEntriesBoundParams =
16035 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
16036 let _ = DocApi::new(invoker).toc().list_entries(¶ms).await;
16037 }
16038
16039 {
16040 let params:DocTocMarkEntryBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"inline-insert\",\"anchor\":{\"nodeType\":\"paragraph\",\"nodeId\":\"\"}},\"text\":\"\"}").expect("generated inhabited parameter fixture");
16041 let _ = DocApi::new(invoker).toc().mark_entry(¶ms).await;
16042 }
16043
16044 {
16045 let params: DocTocRemoveBoundParams = serde_json::from_str(
16046 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"tableOfContents\",\"nodeId\":\"\"}}",
16047 )
16048 .expect("generated inhabited parameter fixture");
16049 let _ = DocApi::new(invoker).toc().remove(¶ms).await;
16050 }
16051
16052 {
16053 let params:DocTocUnmarkEntryBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"inline\",\"nodeType\":\"tableOfContentsEntry\",\"nodeId\":\"\"}}").expect("generated inhabited parameter fixture");
16054 let _ = DocApi::new(invoker).toc().unmark_entry(¶ms).await;
16055 }
16056
16057 {
16058 let params: DocTocUpdateBoundParams = serde_json::from_str(
16059 "{\"target\":{\"kind\":\"block\",\"nodeType\":\"tableOfContents\",\"nodeId\":\"\"}}",
16060 )
16061 .expect("generated inhabited parameter fixture");
16062 let _ = DocApi::new(invoker).toc().update(¶ms).await;
16063 }
16064
16065 {
16066 let params: DocTrackChangesDecideBoundParams = serde_json::from_str(
16067 "{\"decision\":\"accept\",\"target\":{\"kind\":\"id\",\"id\":\"\"}}",
16068 )
16069 .expect("generated inhabited parameter fixture");
16070 let _ = DocApi::new(invoker).track_changes().decide(¶ms).await;
16071 }
16072
16073 {
16074 let params: DocTrackChangesGetBoundParams =
16075 serde_json::from_str("{\"id\":\"\"}").expect("generated inhabited parameter fixture");
16076 let _ = DocApi::new(invoker).track_changes().get(¶ms).await;
16077 }
16078
16079 {
16080 let params: DocTrackChangesListBoundParams =
16081 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
16082 let _ = DocApi::new(invoker).track_changes().list(¶ms).await;
16083 }
16084
16085 {
16086 let params: DocWatermarksApplyBoundParams =
16087 serde_json::from_str("{\"target\":{\"kind\":\"document\"},\"action\":\"insert\"}")
16088 .expect("generated inhabited parameter fixture");
16089 let _ = DocApi::new(invoker).watermarks().apply(¶ms).await;
16090 }
16091
16092 {
16093 let params: DocWatermarksInsertBoundParams = serde_json::from_str(
16094 "{\"target\":{\"kind\":\"document\"},\"watermark\":{\"kind\":\"text\",\"text\":\"\"}}",
16095 )
16096 .expect("generated inhabited parameter fixture");
16097 let _ = DocApi::new(invoker).watermarks().insert(¶ms).await;
16098 }
16099
16100 {
16101 let params: DocWatermarksListBoundParams =
16102 serde_json::from_str("{}").expect("generated inhabited parameter fixture");
16103 let _ = DocApi::new(invoker).watermarks().list(¶ms).await;
16104 }
16105
16106 {
16107 let params: DocWatermarksRemoveBoundParams =
16108 serde_json::from_str("{\"target\":{\"kind\":\"watermark\",\"watermarkId\":\"\"}}")
16109 .expect("generated inhabited parameter fixture");
16110 let _ = DocApi::new(invoker).watermarks().remove(¶ms).await;
16111 }
16112
16113 {
16114 let params:DocWatermarksReplaceBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"watermark\",\"watermarkId\":\"\"},\"watermark\":{\"kind\":\"text\",\"text\":\"\"}}").expect("generated inhabited parameter fixture");
16115 let _ = DocApi::new(invoker).watermarks().replace(¶ms).await;
16116 }
16117}