// Generated by the shared SDK contract. Do not edit.
use super::types::*;
use crate::invoke::{Error, InvokeOptions, Invoker, Result};
pub struct DocApi<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApi<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub fn authorities(&self) -> DocApiAuthorities<'a, I> {
DocApiAuthorities::new(self.invoker)
}
pub fn blocks(&self) -> DocApiBlocks<'a, I> {
DocApiBlocks::new(self.invoker)
}
pub fn bookmarks(&self) -> DocApiBookmarks<'a, I> {
DocApiBookmarks::new(self.invoker)
}
pub fn capabilities(&self) -> DocApiCapabilities<'a, I> {
DocApiCapabilities::new(self.invoker)
}
pub fn captions(&self) -> DocApiCaptions<'a, I> {
DocApiCaptions::new(self.invoker)
}
pub fn citations(&self) -> DocApiCitations<'a, I> {
DocApiCitations::new(self.invoker)
}
pub fn clipboard(&self) -> DocApiClipboard<'a, I> {
DocApiClipboard::new(self.invoker)
}
pub fn comments(&self) -> DocApiComments<'a, I> {
DocApiComments::new(self.invoker)
}
pub fn content_controls(&self) -> DocApiContentControls<'a, I> {
DocApiContentControls::new(self.invoker)
}
pub fn create(&self) -> DocApiCreate<'a, I> {
DocApiCreate::new(self.invoker)
}
pub fn cross_refs(&self) -> DocApiCrossRefs<'a, I> {
DocApiCrossRefs::new(self.invoker)
}
pub fn custom_xml(&self) -> DocApiCustomXml<'a, I> {
DocApiCustomXml::new(self.invoker)
}
pub fn diff(&self) -> DocApiDiff<'a, I> {
DocApiDiff::new(self.invoker)
}
pub fn export(&self) -> DocApiExport<'a, I> {
DocApiExport::new(self.invoker)
}
pub fn fields(&self) -> DocApiFields<'a, I> {
DocApiFields::new(self.invoker)
}
pub fn footnotes(&self) -> DocApiFootnotes<'a, I> {
DocApiFootnotes::new(self.invoker)
}
pub fn format(&self) -> DocApiFormat<'a, I> {
DocApiFormat::new(self.invoker)
}
pub fn header_footers(&self) -> DocApiHeaderFooters<'a, I> {
DocApiHeaderFooters::new(self.invoker)
}
pub fn history(&self) -> DocApiHistory<'a, I> {
DocApiHistory::new(self.invoker)
}
pub fn hyperlinks(&self) -> DocApiHyperlinks<'a, I> {
DocApiHyperlinks::new(self.invoker)
}
pub fn images(&self) -> DocApiImages<'a, I> {
DocApiImages::new(self.invoker)
}
pub fn index(&self) -> DocApiIndex<'a, I> {
DocApiIndex::new(self.invoker)
}
pub fn lists(&self) -> DocApiLists<'a, I> {
DocApiLists::new(self.invoker)
}
pub fn metadata(&self) -> DocApiMetadata<'a, I> {
DocApiMetadata::new(self.invoker)
}
pub fn mutations(&self) -> DocApiMutations<'a, I> {
DocApiMutations::new(self.invoker)
}
pub fn permission_ranges(&self) -> DocApiPermissionRanges<'a, I> {
DocApiPermissionRanges::new(self.invoker)
}
pub fn plan(&self) -> DocApiPlan<'a, I> {
DocApiPlan::new(self.invoker)
}
pub fn preset(&self) -> DocApiPreset<'a, I> {
DocApiPreset::new(self.invoker)
}
pub fn protection(&self) -> DocApiProtection<'a, I> {
DocApiProtection::new(self.invoker)
}
pub fn query(&self) -> DocApiQuery<'a, I> {
DocApiQuery::new(self.invoker)
}
pub fn ranges(&self) -> DocApiRanges<'a, I> {
DocApiRanges::new(self.invoker)
}
pub fn sections(&self) -> DocApiSections<'a, I> {
DocApiSections::new(self.invoker)
}
pub fn selection(&self) -> DocApiSelection<'a, I> {
DocApiSelection::new(self.invoker)
}
pub fn styles(&self) -> DocApiStyles<'a, I> {
DocApiStyles::new(self.invoker)
}
pub fn tables(&self) -> DocApiTables<'a, I> {
DocApiTables::new(self.invoker)
}
pub fn templates(&self) -> DocApiTemplates<'a, I> {
DocApiTemplates::new(self.invoker)
}
pub fn toc(&self) -> DocApiToc<'a, I> {
DocApiToc::new(self.invoker)
}
pub fn track_changes(&self) -> DocApiTrackChanges<'a, I> {
DocApiTrackChanges::new(self.invoker)
}
pub fn watermarks(&self) -> DocApiWatermarks<'a, I> {
DocApiWatermarks::new(self.invoker)
}
pub async fn clear_content(
&self,
params: &DocClearContentBoundParams,
) -> Result<DocClearContentResult> {
self.clear_content_with_options(params, InvokeOptions::default())
.await
}
pub async fn clear_content_with_options(
&self,
params: &DocClearContentBoundParams,
options: InvokeOptions,
) -> Result<DocClearContentResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.clearContent", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.clearContent".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn close(&self, params: &DocCloseBoundParams) -> Result<DocCloseResult> {
self.close_with_options(params, InvokeOptions::default())
.await
}
pub async fn close_with_options(
&self,
params: &DocCloseBoundParams,
options: InvokeOptions,
) -> Result<DocCloseResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self.invoker.invoke("doc.close", params, options).await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.close".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn delete(&self, params: &DocDeleteBoundParams) -> Result<DocDeleteResult> {
self.delete_with_options(params, InvokeOptions::default())
.await
}
pub async fn delete_with_options(
&self,
params: &DocDeleteBoundParams,
options: InvokeOptions,
) -> Result<DocDeleteResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self.invoker.invoke("doc.delete", params, options).await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.delete".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn execute_code(
&self,
params: &DocExecuteCodeBoundParams,
) -> Result<DocExecuteCodeResult> {
self.execute_code_with_options(params, InvokeOptions::default())
.await
}
pub async fn execute_code_with_options(
&self,
params: &DocExecuteCodeBoundParams,
options: InvokeOptions,
) -> Result<DocExecuteCodeResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.executeCode", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.executeCode".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn extract(&self, params: &DocExtractBoundParams) -> Result<DocExtractResult> {
self.extract_with_options(params, InvokeOptions::default())
.await
}
pub async fn extract_with_options(
&self,
params: &DocExtractBoundParams,
options: InvokeOptions,
) -> Result<DocExtractResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self.invoker.invoke("doc.extract", params, options).await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.extract".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn find(&self, params: &DocFindBoundParams) -> Result<DocFindResult> {
self.find_with_options(params, InvokeOptions::default())
.await
}
pub async fn find_with_options(
&self,
params: &DocFindBoundParams,
options: InvokeOptions,
) -> Result<DocFindResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self.invoker.invoke("doc.find", params, options).await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.find".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn format_range(
&self,
params: &DocFormatRangeBoundParams,
) -> Result<DocFormatRangeResult> {
self.format_range_with_options(params, InvokeOptions::default())
.await
}
pub async fn format_range_with_options(
&self,
params: &DocFormatRangeBoundParams,
options: InvokeOptions,
) -> Result<DocFormatRangeResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.formatRange", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.formatRange".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn get(&self, params: &DocGetBoundParams) -> Result<DocGetResult> {
self.get_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_with_options(
&self,
params: &DocGetBoundParams,
options: InvokeOptions,
) -> Result<DocGetResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self.invoker.invoke("doc.get", params, options).await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.get".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn get_html(&self, params: &DocGetHtmlBoundParams) -> Result<DocGetHtmlResult> {
self.get_html_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_html_with_options(
&self,
params: &DocGetHtmlBoundParams,
options: InvokeOptions,
) -> Result<DocGetHtmlResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self.invoker.invoke("doc.getHtml", params, options).await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.getHtml".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn get_markdown(
&self,
params: &DocGetMarkdownBoundParams,
) -> Result<DocGetMarkdownResult> {
self.get_markdown_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_markdown_with_options(
&self,
params: &DocGetMarkdownBoundParams,
options: InvokeOptions,
) -> Result<DocGetMarkdownResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.getMarkdown", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.getMarkdown".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn get_node(&self, params: &DocGetNodeBoundParams) -> Result<DocGetNodeResult> {
self.get_node_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_node_with_options(
&self,
params: &DocGetNodeBoundParams,
options: InvokeOptions,
) -> Result<DocGetNodeResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self.invoker.invoke("doc.getNode", params, options).await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.getNode".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn get_node_by_id(
&self,
params: &DocGetNodeByIdBoundParams,
) -> Result<DocGetNodeByIdResult> {
self.get_node_by_id_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_node_by_id_with_options(
&self,
params: &DocGetNodeByIdBoundParams,
options: InvokeOptions,
) -> Result<DocGetNodeByIdResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.getNodeById", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.getNodeById".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn get_text(&self, params: &DocGetTextBoundParams) -> Result<DocGetTextResult> {
self.get_text_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_text_with_options(
&self,
params: &DocGetTextBoundParams,
options: InvokeOptions,
) -> Result<DocGetTextResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self.invoker.invoke("doc.getText", params, options).await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.getText".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn html_to_fragment(
&self,
params: &DocHtmlToFragmentBoundParams,
) -> Result<DocHtmlToFragmentResult> {
self.html_to_fragment_with_options(params, InvokeOptions::default())
.await
}
pub async fn html_to_fragment_with_options(
&self,
params: &DocHtmlToFragmentBoundParams,
options: InvokeOptions,
) -> Result<DocHtmlToFragmentResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.htmlToFragment", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.htmlToFragment".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn info(&self, params: &DocInfoBoundParams) -> Result<DocInfoResult> {
self.info_with_options(params, InvokeOptions::default())
.await
}
pub async fn info_with_options(
&self,
params: &DocInfoBoundParams,
options: InvokeOptions,
) -> Result<DocInfoResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self.invoker.invoke("doc.info", params, options).await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.info".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn insert(&self, params: &DocInsertBoundParams) -> Result<DocInsertResult> {
self.insert_with_options(params, InvokeOptions::default())
.await
}
pub async fn insert_with_options(
&self,
params: &DocInsertBoundParams,
options: InvokeOptions,
) -> Result<DocInsertResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self.invoker.invoke("doc.insert", params, options).await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.insert".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn insert_line_break(
&self,
params: &DocInsertLineBreakBoundParams,
) -> Result<DocInsertLineBreakResult> {
self.insert_line_break_with_options(params, InvokeOptions::default())
.await
}
pub async fn insert_line_break_with_options(
&self,
params: &DocInsertLineBreakBoundParams,
options: InvokeOptions,
) -> Result<DocInsertLineBreakResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.insertLineBreak", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.insertLineBreak".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn insert_tab(&self, params: &DocInsertTabBoundParams) -> Result<DocInsertTabResult> {
self.insert_tab_with_options(params, InvokeOptions::default())
.await
}
pub async fn insert_tab_with_options(
&self,
params: &DocInsertTabBoundParams,
options: InvokeOptions,
) -> Result<DocInsertTabResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.insertTab", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.insertTab".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn markdown_to_fragment(
&self,
params: &DocMarkdownToFragmentBoundParams,
) -> Result<DocMarkdownToFragmentResult> {
self.markdown_to_fragment_with_options(params, InvokeOptions::default())
.await
}
pub async fn markdown_to_fragment_with_options(
&self,
params: &DocMarkdownToFragmentBoundParams,
options: InvokeOptions,
) -> Result<DocMarkdownToFragmentResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.markdownToFragment", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.markdownToFragment".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn project_html(
&self,
params: &DocProjectHtmlBoundParams,
) -> Result<DocProjectHtmlResult> {
self.project_html_with_options(params, InvokeOptions::default())
.await
}
pub async fn project_html_with_options(
&self,
params: &DocProjectHtmlBoundParams,
options: InvokeOptions,
) -> Result<DocProjectHtmlResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.projectHtml", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.projectHtml".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn project_markdown(
&self,
params: &DocProjectMarkdownBoundParams,
) -> Result<DocProjectMarkdownResult> {
self.project_markdown_with_options(params, InvokeOptions::default())
.await
}
pub async fn project_markdown_with_options(
&self,
params: &DocProjectMarkdownBoundParams,
options: InvokeOptions,
) -> Result<DocProjectMarkdownResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.projectMarkdown", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.projectMarkdown".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn replace(&self, params: &DocReplaceBoundParams) -> Result<DocReplaceResult> {
self.replace_with_options(params, InvokeOptions::default())
.await
}
pub async fn replace_with_options(
&self,
params: &DocReplaceBoundParams,
options: InvokeOptions,
) -> Result<DocReplaceResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self.invoker.invoke("doc.replace", params, options).await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.replace".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn save(&self, params: &DocSaveBoundParams) -> Result<DocSaveResult> {
self.save_with_options(params, InvokeOptions::default())
.await
}
pub async fn save_with_options(
&self,
params: &DocSaveBoundParams,
options: InvokeOptions,
) -> Result<DocSaveResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self.invoker.invoke("doc.save", params, options).await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.save".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiAuthorities<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiAuthorities<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub fn entries(&self) -> DocApiAuthoritiesEntries<'a, I> {
DocApiAuthoritiesEntries::new(self.invoker)
}
pub async fn configure(
&self,
params: &DocAuthoritiesConfigureBoundParams,
) -> Result<DocAuthoritiesConfigureResult> {
self.configure_with_options(params, InvokeOptions::default())
.await
}
pub async fn configure_with_options(
&self,
params: &DocAuthoritiesConfigureBoundParams,
options: InvokeOptions,
) -> Result<DocAuthoritiesConfigureResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.authorities.configure", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.authorities.configure".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn get(
&self,
params: &DocAuthoritiesGetBoundParams,
) -> Result<DocAuthoritiesGetResult> {
self.get_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_with_options(
&self,
params: &DocAuthoritiesGetBoundParams,
options: InvokeOptions,
) -> Result<DocAuthoritiesGetResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.authorities.get", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.authorities.get".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn insert(
&self,
params: &DocAuthoritiesInsertBoundParams,
) -> Result<DocAuthoritiesInsertResult> {
self.insert_with_options(params, InvokeOptions::default())
.await
}
pub async fn insert_with_options(
&self,
params: &DocAuthoritiesInsertBoundParams,
options: InvokeOptions,
) -> Result<DocAuthoritiesInsertResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.authorities.insert", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.authorities.insert".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn list(
&self,
params: &DocAuthoritiesListBoundParams,
) -> Result<DocAuthoritiesListResult> {
self.list_with_options(params, InvokeOptions::default())
.await
}
pub async fn list_with_options(
&self,
params: &DocAuthoritiesListBoundParams,
options: InvokeOptions,
) -> Result<DocAuthoritiesListResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.authorities.list", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.authorities.list".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn rebuild(
&self,
params: &DocAuthoritiesRebuildBoundParams,
) -> Result<DocAuthoritiesRebuildResult> {
self.rebuild_with_options(params, InvokeOptions::default())
.await
}
pub async fn rebuild_with_options(
&self,
params: &DocAuthoritiesRebuildBoundParams,
options: InvokeOptions,
) -> Result<DocAuthoritiesRebuildResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.authorities.rebuild", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.authorities.rebuild".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn remove(
&self,
params: &DocAuthoritiesRemoveBoundParams,
) -> Result<DocAuthoritiesRemoveResult> {
self.remove_with_options(params, InvokeOptions::default())
.await
}
pub async fn remove_with_options(
&self,
params: &DocAuthoritiesRemoveBoundParams,
options: InvokeOptions,
) -> Result<DocAuthoritiesRemoveResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.authorities.remove", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.authorities.remove".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiAuthoritiesEntries<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiAuthoritiesEntries<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn get(
&self,
params: &DocAuthoritiesEntriesGetBoundParams,
) -> Result<DocAuthoritiesEntriesGetResult> {
self.get_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_with_options(
&self,
params: &DocAuthoritiesEntriesGetBoundParams,
options: InvokeOptions,
) -> Result<DocAuthoritiesEntriesGetResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.authorities.entries.get", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.authorities.entries.get".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn insert(
&self,
params: &DocAuthoritiesEntriesInsertBoundParams,
) -> Result<DocAuthoritiesEntriesInsertResult> {
self.insert_with_options(params, InvokeOptions::default())
.await
}
pub async fn insert_with_options(
&self,
params: &DocAuthoritiesEntriesInsertBoundParams,
options: InvokeOptions,
) -> Result<DocAuthoritiesEntriesInsertResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.authorities.entries.insert", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.authorities.entries.insert".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn list(
&self,
params: &DocAuthoritiesEntriesListBoundParams,
) -> Result<DocAuthoritiesEntriesListResult> {
self.list_with_options(params, InvokeOptions::default())
.await
}
pub async fn list_with_options(
&self,
params: &DocAuthoritiesEntriesListBoundParams,
options: InvokeOptions,
) -> Result<DocAuthoritiesEntriesListResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.authorities.entries.list", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.authorities.entries.list".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn remove(
&self,
params: &DocAuthoritiesEntriesRemoveBoundParams,
) -> Result<DocAuthoritiesEntriesRemoveResult> {
self.remove_with_options(params, InvokeOptions::default())
.await
}
pub async fn remove_with_options(
&self,
params: &DocAuthoritiesEntriesRemoveBoundParams,
options: InvokeOptions,
) -> Result<DocAuthoritiesEntriesRemoveResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.authorities.entries.remove", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.authorities.entries.remove".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn update(
&self,
params: &DocAuthoritiesEntriesUpdateBoundParams,
) -> Result<DocAuthoritiesEntriesUpdateResult> {
self.update_with_options(params, InvokeOptions::default())
.await
}
pub async fn update_with_options(
&self,
params: &DocAuthoritiesEntriesUpdateBoundParams,
options: InvokeOptions,
) -> Result<DocAuthoritiesEntriesUpdateResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.authorities.entries.update", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.authorities.entries.update".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiBlocks<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiBlocks<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn delete(
&self,
params: &DocBlocksDeleteBoundParams,
) -> Result<DocBlocksDeleteResult> {
self.delete_with_options(params, InvokeOptions::default())
.await
}
pub async fn delete_with_options(
&self,
params: &DocBlocksDeleteBoundParams,
options: InvokeOptions,
) -> Result<DocBlocksDeleteResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.blocks.delete", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.blocks.delete".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn delete_range(
&self,
params: &DocBlocksDeleteRangeBoundParams,
) -> Result<DocBlocksDeleteRangeResult> {
self.delete_range_with_options(params, InvokeOptions::default())
.await
}
pub async fn delete_range_with_options(
&self,
params: &DocBlocksDeleteRangeBoundParams,
options: InvokeOptions,
) -> Result<DocBlocksDeleteRangeResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.blocks.deleteRange", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.blocks.deleteRange".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn find_text(
&self,
params: &DocBlocksFindTextBoundParams,
) -> Result<DocBlocksFindTextResult> {
self.find_text_with_options(params, InvokeOptions::default())
.await
}
pub async fn find_text_with_options(
&self,
params: &DocBlocksFindTextBoundParams,
options: InvokeOptions,
) -> Result<DocBlocksFindTextResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.blocks.findText", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.blocks.findText".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn list(&self, params: &DocBlocksListBoundParams) -> Result<DocBlocksListResult> {
self.list_with_options(params, InvokeOptions::default())
.await
}
pub async fn list_with_options(
&self,
params: &DocBlocksListBoundParams,
options: InvokeOptions,
) -> Result<DocBlocksListResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.blocks.list", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.blocks.list".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn merge(&self, params: &DocBlocksMergeBoundParams) -> Result<DocBlocksMergeResult> {
self.merge_with_options(params, InvokeOptions::default())
.await
}
pub async fn merge_with_options(
&self,
params: &DocBlocksMergeBoundParams,
options: InvokeOptions,
) -> Result<DocBlocksMergeResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.blocks.merge", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.blocks.merge".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn move_(&self, params: &DocBlocksMoveBoundParams) -> Result<DocBlocksMoveResult> {
self.move_with_options(params, InvokeOptions::default())
.await
}
pub async fn move_with_options(
&self,
params: &DocBlocksMoveBoundParams,
options: InvokeOptions,
) -> Result<DocBlocksMoveResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.blocks.move", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.blocks.move".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn split(&self, params: &DocBlocksSplitBoundParams) -> Result<DocBlocksSplitResult> {
self.split_with_options(params, InvokeOptions::default())
.await
}
pub async fn split_with_options(
&self,
params: &DocBlocksSplitBoundParams,
options: InvokeOptions,
) -> Result<DocBlocksSplitResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.blocks.split", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.blocks.split".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiBookmarks<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiBookmarks<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn get(&self, params: &DocBookmarksGetBoundParams) -> Result<DocBookmarksGetResult> {
self.get_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_with_options(
&self,
params: &DocBookmarksGetBoundParams,
options: InvokeOptions,
) -> Result<DocBookmarksGetResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.bookmarks.get", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.bookmarks.get".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn insert(
&self,
params: &DocBookmarksInsertBoundParams,
) -> Result<DocBookmarksInsertResult> {
self.insert_with_options(params, InvokeOptions::default())
.await
}
pub async fn insert_with_options(
&self,
params: &DocBookmarksInsertBoundParams,
options: InvokeOptions,
) -> Result<DocBookmarksInsertResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.bookmarks.insert", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.bookmarks.insert".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn list(
&self,
params: &DocBookmarksListBoundParams,
) -> Result<DocBookmarksListResult> {
self.list_with_options(params, InvokeOptions::default())
.await
}
pub async fn list_with_options(
&self,
params: &DocBookmarksListBoundParams,
options: InvokeOptions,
) -> Result<DocBookmarksListResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.bookmarks.list", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.bookmarks.list".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn remove(
&self,
params: &DocBookmarksRemoveBoundParams,
) -> Result<DocBookmarksRemoveResult> {
self.remove_with_options(params, InvokeOptions::default())
.await
}
pub async fn remove_with_options(
&self,
params: &DocBookmarksRemoveBoundParams,
options: InvokeOptions,
) -> Result<DocBookmarksRemoveResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.bookmarks.remove", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.bookmarks.remove".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn rename(
&self,
params: &DocBookmarksRenameBoundParams,
) -> Result<DocBookmarksRenameResult> {
self.rename_with_options(params, InvokeOptions::default())
.await
}
pub async fn rename_with_options(
&self,
params: &DocBookmarksRenameBoundParams,
options: InvokeOptions,
) -> Result<DocBookmarksRenameResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.bookmarks.rename", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.bookmarks.rename".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiCapabilities<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiCapabilities<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn check(
&self,
params: &DocCapabilitiesCheckBoundParams,
) -> Result<DocCapabilitiesCheckResult> {
self.check_with_options(params, InvokeOptions::default())
.await
}
pub async fn check_with_options(
&self,
params: &DocCapabilitiesCheckBoundParams,
options: InvokeOptions,
) -> Result<DocCapabilitiesCheckResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.capabilities.check", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.capabilities.check".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn get(
&self,
params: &DocCapabilitiesGetBoundParams,
) -> Result<DocCapabilitiesGetResult> {
self.get_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_with_options(
&self,
params: &DocCapabilitiesGetBoundParams,
options: InvokeOptions,
) -> Result<DocCapabilitiesGetResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.capabilities.get", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.capabilities.get".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn resolve(
&self,
params: &DocCapabilitiesResolveBoundParams,
) -> Result<DocCapabilitiesResolveResult> {
self.resolve_with_options(params, InvokeOptions::default())
.await
}
pub async fn resolve_with_options(
&self,
params: &DocCapabilitiesResolveBoundParams,
options: InvokeOptions,
) -> Result<DocCapabilitiesResolveResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.capabilities.resolve", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.capabilities.resolve".to_owned());
error.outcome_unknown = false;
error
})
}
}
pub struct DocApiCaptions<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiCaptions<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn configure(
&self,
params: &DocCaptionsConfigureBoundParams,
) -> Result<DocCaptionsConfigureResult> {
self.configure_with_options(params, InvokeOptions::default())
.await
}
pub async fn configure_with_options(
&self,
params: &DocCaptionsConfigureBoundParams,
options: InvokeOptions,
) -> Result<DocCaptionsConfigureResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.captions.configure", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.captions.configure".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn get(&self, params: &DocCaptionsGetBoundParams) -> Result<DocCaptionsGetResult> {
self.get_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_with_options(
&self,
params: &DocCaptionsGetBoundParams,
options: InvokeOptions,
) -> Result<DocCaptionsGetResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.captions.get", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.captions.get".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn insert(
&self,
params: &DocCaptionsInsertBoundParams,
) -> Result<DocCaptionsInsertResult> {
self.insert_with_options(params, InvokeOptions::default())
.await
}
pub async fn insert_with_options(
&self,
params: &DocCaptionsInsertBoundParams,
options: InvokeOptions,
) -> Result<DocCaptionsInsertResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.captions.insert", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.captions.insert".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn list(&self, params: &DocCaptionsListBoundParams) -> Result<DocCaptionsListResult> {
self.list_with_options(params, InvokeOptions::default())
.await
}
pub async fn list_with_options(
&self,
params: &DocCaptionsListBoundParams,
options: InvokeOptions,
) -> Result<DocCaptionsListResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.captions.list", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.captions.list".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn remove(
&self,
params: &DocCaptionsRemoveBoundParams,
) -> Result<DocCaptionsRemoveResult> {
self.remove_with_options(params, InvokeOptions::default())
.await
}
pub async fn remove_with_options(
&self,
params: &DocCaptionsRemoveBoundParams,
options: InvokeOptions,
) -> Result<DocCaptionsRemoveResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.captions.remove", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.captions.remove".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn update(
&self,
params: &DocCaptionsUpdateBoundParams,
) -> Result<DocCaptionsUpdateResult> {
self.update_with_options(params, InvokeOptions::default())
.await
}
pub async fn update_with_options(
&self,
params: &DocCaptionsUpdateBoundParams,
options: InvokeOptions,
) -> Result<DocCaptionsUpdateResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.captions.update", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.captions.update".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiCitations<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiCitations<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub fn bibliography(&self) -> DocApiCitationsBibliography<'a, I> {
DocApiCitationsBibliography::new(self.invoker)
}
pub fn sources(&self) -> DocApiCitationsSources<'a, I> {
DocApiCitationsSources::new(self.invoker)
}
pub async fn get(&self, params: &DocCitationsGetBoundParams) -> Result<DocCitationsGetResult> {
self.get_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_with_options(
&self,
params: &DocCitationsGetBoundParams,
options: InvokeOptions,
) -> Result<DocCitationsGetResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.citations.get", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.citations.get".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn insert(
&self,
params: &DocCitationsInsertBoundParams,
) -> Result<DocCitationsInsertResult> {
self.insert_with_options(params, InvokeOptions::default())
.await
}
pub async fn insert_with_options(
&self,
params: &DocCitationsInsertBoundParams,
options: InvokeOptions,
) -> Result<DocCitationsInsertResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.citations.insert", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.citations.insert".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn list(
&self,
params: &DocCitationsListBoundParams,
) -> Result<DocCitationsListResult> {
self.list_with_options(params, InvokeOptions::default())
.await
}
pub async fn list_with_options(
&self,
params: &DocCitationsListBoundParams,
options: InvokeOptions,
) -> Result<DocCitationsListResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.citations.list", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.citations.list".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn remove(
&self,
params: &DocCitationsRemoveBoundParams,
) -> Result<DocCitationsRemoveResult> {
self.remove_with_options(params, InvokeOptions::default())
.await
}
pub async fn remove_with_options(
&self,
params: &DocCitationsRemoveBoundParams,
options: InvokeOptions,
) -> Result<DocCitationsRemoveResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.citations.remove", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.citations.remove".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn update(
&self,
params: &DocCitationsUpdateBoundParams,
) -> Result<DocCitationsUpdateResult> {
self.update_with_options(params, InvokeOptions::default())
.await
}
pub async fn update_with_options(
&self,
params: &DocCitationsUpdateBoundParams,
options: InvokeOptions,
) -> Result<DocCitationsUpdateResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.citations.update", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.citations.update".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiCitationsBibliography<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiCitationsBibliography<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn configure(
&self,
params: &DocCitationsBibliographyConfigureBoundParams,
) -> Result<DocCitationsBibliographyConfigureResult> {
self.configure_with_options(params, InvokeOptions::default())
.await
}
pub async fn configure_with_options(
&self,
params: &DocCitationsBibliographyConfigureBoundParams,
options: InvokeOptions,
) -> Result<DocCitationsBibliographyConfigureResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.citations.bibliography.configure", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.citations.bibliography.configure".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn get(
&self,
params: &DocCitationsBibliographyGetBoundParams,
) -> Result<DocCitationsBibliographyGetResult> {
self.get_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_with_options(
&self,
params: &DocCitationsBibliographyGetBoundParams,
options: InvokeOptions,
) -> Result<DocCitationsBibliographyGetResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.citations.bibliography.get", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.citations.bibliography.get".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn insert(
&self,
params: &DocCitationsBibliographyInsertBoundParams,
) -> Result<DocCitationsBibliographyInsertResult> {
self.insert_with_options(params, InvokeOptions::default())
.await
}
pub async fn insert_with_options(
&self,
params: &DocCitationsBibliographyInsertBoundParams,
options: InvokeOptions,
) -> Result<DocCitationsBibliographyInsertResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.citations.bibliography.insert", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.citations.bibliography.insert".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn rebuild(
&self,
params: &DocCitationsBibliographyRebuildBoundParams,
) -> Result<DocCitationsBibliographyRebuildResult> {
self.rebuild_with_options(params, InvokeOptions::default())
.await
}
pub async fn rebuild_with_options(
&self,
params: &DocCitationsBibliographyRebuildBoundParams,
options: InvokeOptions,
) -> Result<DocCitationsBibliographyRebuildResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.citations.bibliography.rebuild", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.citations.bibliography.rebuild".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn remove(
&self,
params: &DocCitationsBibliographyRemoveBoundParams,
) -> Result<DocCitationsBibliographyRemoveResult> {
self.remove_with_options(params, InvokeOptions::default())
.await
}
pub async fn remove_with_options(
&self,
params: &DocCitationsBibliographyRemoveBoundParams,
options: InvokeOptions,
) -> Result<DocCitationsBibliographyRemoveResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.citations.bibliography.remove", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.citations.bibliography.remove".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiCitationsSources<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiCitationsSources<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn get(
&self,
params: &DocCitationsSourcesGetBoundParams,
) -> Result<DocCitationsSourcesGetResult> {
self.get_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_with_options(
&self,
params: &DocCitationsSourcesGetBoundParams,
options: InvokeOptions,
) -> Result<DocCitationsSourcesGetResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.citations.sources.get", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.citations.sources.get".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn insert(
&self,
params: &DocCitationsSourcesInsertBoundParams,
) -> Result<DocCitationsSourcesInsertResult> {
self.insert_with_options(params, InvokeOptions::default())
.await
}
pub async fn insert_with_options(
&self,
params: &DocCitationsSourcesInsertBoundParams,
options: InvokeOptions,
) -> Result<DocCitationsSourcesInsertResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.citations.sources.insert", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.citations.sources.insert".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn list(
&self,
params: &DocCitationsSourcesListBoundParams,
) -> Result<DocCitationsSourcesListResult> {
self.list_with_options(params, InvokeOptions::default())
.await
}
pub async fn list_with_options(
&self,
params: &DocCitationsSourcesListBoundParams,
options: InvokeOptions,
) -> Result<DocCitationsSourcesListResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.citations.sources.list", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.citations.sources.list".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn remove(
&self,
params: &DocCitationsSourcesRemoveBoundParams,
) -> Result<DocCitationsSourcesRemoveResult> {
self.remove_with_options(params, InvokeOptions::default())
.await
}
pub async fn remove_with_options(
&self,
params: &DocCitationsSourcesRemoveBoundParams,
options: InvokeOptions,
) -> Result<DocCitationsSourcesRemoveResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.citations.sources.remove", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.citations.sources.remove".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn update(
&self,
params: &DocCitationsSourcesUpdateBoundParams,
) -> Result<DocCitationsSourcesUpdateResult> {
self.update_with_options(params, InvokeOptions::default())
.await
}
pub async fn update_with_options(
&self,
params: &DocCitationsSourcesUpdateBoundParams,
options: InvokeOptions,
) -> Result<DocCitationsSourcesUpdateResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.citations.sources.update", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.citations.sources.update".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiClipboard<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiClipboard<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn insert(
&self,
params: &DocClipboardInsertBoundParams,
) -> Result<DocClipboardInsertResult> {
self.insert_with_options(params, InvokeOptions::default())
.await
}
pub async fn insert_with_options(
&self,
params: &DocClipboardInsertBoundParams,
options: InvokeOptions,
) -> Result<DocClipboardInsertResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.clipboard.insert", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.clipboard.insert".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn parse(
&self,
params: &DocClipboardParseBoundParams,
) -> Result<DocClipboardParseResult> {
self.parse_with_options(params, InvokeOptions::default())
.await
}
pub async fn parse_with_options(
&self,
params: &DocClipboardParseBoundParams,
options: InvokeOptions,
) -> Result<DocClipboardParseResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.clipboard.parse", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.clipboard.parse".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn serialize_selection(
&self,
params: &DocClipboardSerializeSelectionBoundParams,
) -> Result<DocClipboardSerializeSelectionResult> {
self.serialize_selection_with_options(params, InvokeOptions::default())
.await
}
pub async fn serialize_selection_with_options(
&self,
params: &DocClipboardSerializeSelectionBoundParams,
options: InvokeOptions,
) -> Result<DocClipboardSerializeSelectionResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.clipboard.serializeSelection", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.clipboard.serializeSelection".to_owned());
error.outcome_unknown = false;
error
})
}
}
pub struct DocApiComments<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiComments<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn create(
&self,
params: &DocCommentsCreateBoundParams,
) -> Result<DocCommentsCreateResult> {
self.create_with_options(params, InvokeOptions::default())
.await
}
pub async fn create_with_options(
&self,
params: &DocCommentsCreateBoundParams,
options: InvokeOptions,
) -> Result<DocCommentsCreateResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.comments.create", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.comments.create".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn delete(
&self,
params: &DocCommentsDeleteBoundParams,
) -> Result<DocCommentsDeleteResult> {
self.delete_with_options(params, InvokeOptions::default())
.await
}
pub async fn delete_with_options(
&self,
params: &DocCommentsDeleteBoundParams,
options: InvokeOptions,
) -> Result<DocCommentsDeleteResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.comments.delete", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.comments.delete".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn get(&self, params: &DocCommentsGetBoundParams) -> Result<DocCommentsGetResult> {
self.get_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_with_options(
&self,
params: &DocCommentsGetBoundParams,
options: InvokeOptions,
) -> Result<DocCommentsGetResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.comments.get", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.comments.get".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn list(&self, params: &DocCommentsListBoundParams) -> Result<DocCommentsListResult> {
self.list_with_options(params, InvokeOptions::default())
.await
}
pub async fn list_with_options(
&self,
params: &DocCommentsListBoundParams,
options: InvokeOptions,
) -> Result<DocCommentsListResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.comments.list", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.comments.list".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn patch(
&self,
params: &DocCommentsPatchBoundParams,
) -> Result<DocCommentsPatchResult> {
self.patch_with_options(params, InvokeOptions::default())
.await
}
pub async fn patch_with_options(
&self,
params: &DocCommentsPatchBoundParams,
options: InvokeOptions,
) -> Result<DocCommentsPatchResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.comments.patch", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.comments.patch".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiContentControls<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiContentControls<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub fn checkbox(&self) -> DocApiContentControlsCheckbox<'a, I> {
DocApiContentControlsCheckbox::new(self.invoker)
}
pub fn choice_list(&self) -> DocApiContentControlsChoiceList<'a, I> {
DocApiContentControlsChoiceList::new(self.invoker)
}
pub fn date(&self) -> DocApiContentControlsDate<'a, I> {
DocApiContentControlsDate::new(self.invoker)
}
pub fn group(&self) -> DocApiContentControlsGroup<'a, I> {
DocApiContentControlsGroup::new(self.invoker)
}
pub fn repeating_section(&self) -> DocApiContentControlsRepeatingSection<'a, I> {
DocApiContentControlsRepeatingSection::new(self.invoker)
}
pub fn text(&self) -> DocApiContentControlsText<'a, I> {
DocApiContentControlsText::new(self.invoker)
}
pub async fn append_content(
&self,
params: &DocContentControlsAppendContentBoundParams,
) -> Result<DocContentControlsAppendContentResult> {
self.append_content_with_options(params, InvokeOptions::default())
.await
}
pub async fn append_content_with_options(
&self,
params: &DocContentControlsAppendContentBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsAppendContentResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.appendContent", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.appendContent".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn clear_binding(
&self,
params: &DocContentControlsClearBindingBoundParams,
) -> Result<DocContentControlsClearBindingResult> {
self.clear_binding_with_options(params, InvokeOptions::default())
.await
}
pub async fn clear_binding_with_options(
&self,
params: &DocContentControlsClearBindingBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsClearBindingResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.clearBinding", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.clearBinding".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn clear_content(
&self,
params: &DocContentControlsClearContentBoundParams,
) -> Result<DocContentControlsClearContentResult> {
self.clear_content_with_options(params, InvokeOptions::default())
.await
}
pub async fn clear_content_with_options(
&self,
params: &DocContentControlsClearContentBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsClearContentResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.clearContent", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.clearContent".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn copy(
&self,
params: &DocContentControlsCopyBoundParams,
) -> Result<DocContentControlsCopyResult> {
self.copy_with_options(params, InvokeOptions::default())
.await
}
pub async fn copy_with_options(
&self,
params: &DocContentControlsCopyBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsCopyResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.copy", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.copy".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn delete(
&self,
params: &DocContentControlsDeleteBoundParams,
) -> Result<DocContentControlsDeleteResult> {
self.delete_with_options(params, InvokeOptions::default())
.await
}
pub async fn delete_with_options(
&self,
params: &DocContentControlsDeleteBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsDeleteResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.delete", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.delete".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn get(
&self,
params: &DocContentControlsGetBoundParams,
) -> Result<DocContentControlsGetResult> {
self.get_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_with_options(
&self,
params: &DocContentControlsGetBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsGetResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.get", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.get".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn get_binding(
&self,
params: &DocContentControlsGetBindingBoundParams,
) -> Result<DocContentControlsGetBindingResult> {
self.get_binding_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_binding_with_options(
&self,
params: &DocContentControlsGetBindingBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsGetBindingResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.getBinding", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.getBinding".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn get_content(
&self,
params: &DocContentControlsGetContentBoundParams,
) -> Result<DocContentControlsGetContentResult> {
self.get_content_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_content_with_options(
&self,
params: &DocContentControlsGetContentBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsGetContentResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.getContent", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.getContent".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn get_parent(
&self,
params: &DocContentControlsGetParentBoundParams,
) -> Result<DocContentControlsGetParentResult> {
self.get_parent_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_parent_with_options(
&self,
params: &DocContentControlsGetParentBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsGetParentResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.getParent", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.getParent".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn get_raw_properties(
&self,
params: &DocContentControlsGetRawPropertiesBoundParams,
) -> Result<DocContentControlsGetRawPropertiesResult> {
self.get_raw_properties_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_raw_properties_with_options(
&self,
params: &DocContentControlsGetRawPropertiesBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsGetRawPropertiesResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.getRawProperties", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.getRawProperties".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn insert_after(
&self,
params: &DocContentControlsInsertAfterBoundParams,
) -> Result<DocContentControlsInsertAfterResult> {
self.insert_after_with_options(params, InvokeOptions::default())
.await
}
pub async fn insert_after_with_options(
&self,
params: &DocContentControlsInsertAfterBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsInsertAfterResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.insertAfter", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.insertAfter".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn insert_before(
&self,
params: &DocContentControlsInsertBeforeBoundParams,
) -> Result<DocContentControlsInsertBeforeResult> {
self.insert_before_with_options(params, InvokeOptions::default())
.await
}
pub async fn insert_before_with_options(
&self,
params: &DocContentControlsInsertBeforeBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsInsertBeforeResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.insertBefore", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.insertBefore".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn list(
&self,
params: &DocContentControlsListBoundParams,
) -> Result<DocContentControlsListResult> {
self.list_with_options(params, InvokeOptions::default())
.await
}
pub async fn list_with_options(
&self,
params: &DocContentControlsListBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsListResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.list", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.list".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn list_children(
&self,
params: &DocContentControlsListChildrenBoundParams,
) -> Result<DocContentControlsListChildrenResult> {
self.list_children_with_options(params, InvokeOptions::default())
.await
}
pub async fn list_children_with_options(
&self,
params: &DocContentControlsListChildrenBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsListChildrenResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.listChildren", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.listChildren".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn list_in_range(
&self,
params: &DocContentControlsListInRangeBoundParams,
) -> Result<DocContentControlsListInRangeResult> {
self.list_in_range_with_options(params, InvokeOptions::default())
.await
}
pub async fn list_in_range_with_options(
&self,
params: &DocContentControlsListInRangeBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsListInRangeResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.listInRange", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.listInRange".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn move_(
&self,
params: &DocContentControlsMoveBoundParams,
) -> Result<DocContentControlsMoveResult> {
self.move_with_options(params, InvokeOptions::default())
.await
}
pub async fn move_with_options(
&self,
params: &DocContentControlsMoveBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsMoveResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.move", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.move".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn normalize_tag_payload(
&self,
params: &DocContentControlsNormalizeTagPayloadBoundParams,
) -> Result<DocContentControlsNormalizeTagPayloadResult> {
self.normalize_tag_payload_with_options(params, InvokeOptions::default())
.await
}
pub async fn normalize_tag_payload_with_options(
&self,
params: &DocContentControlsNormalizeTagPayloadBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsNormalizeTagPayloadResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.normalizeTagPayload", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.normalizeTagPayload".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn normalize_word_compatibility(
&self,
params: &DocContentControlsNormalizeWordCompatibilityBoundParams,
) -> Result<DocContentControlsNormalizeWordCompatibilityResult> {
self.normalize_word_compatibility_with_options(params, InvokeOptions::default())
.await
}
pub async fn normalize_word_compatibility_with_options(
&self,
params: &DocContentControlsNormalizeWordCompatibilityBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsNormalizeWordCompatibilityResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke(
"doc.contentControls.normalizeWordCompatibility",
params,
options,
)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.normalizeWordCompatibility".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn patch(
&self,
params: &DocContentControlsPatchBoundParams,
) -> Result<DocContentControlsPatchResult> {
self.patch_with_options(params, InvokeOptions::default())
.await
}
pub async fn patch_with_options(
&self,
params: &DocContentControlsPatchBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsPatchResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.patch", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.patch".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn patch_raw_properties(
&self,
params: &DocContentControlsPatchRawPropertiesBoundParams,
) -> Result<DocContentControlsPatchRawPropertiesResult> {
self.patch_raw_properties_with_options(params, InvokeOptions::default())
.await
}
pub async fn patch_raw_properties_with_options(
&self,
params: &DocContentControlsPatchRawPropertiesBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsPatchRawPropertiesResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.patchRawProperties", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.patchRawProperties".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn prepend_content(
&self,
params: &DocContentControlsPrependContentBoundParams,
) -> Result<DocContentControlsPrependContentResult> {
self.prepend_content_with_options(params, InvokeOptions::default())
.await
}
pub async fn prepend_content_with_options(
&self,
params: &DocContentControlsPrependContentBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsPrependContentResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.prependContent", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.prependContent".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn replace_content(
&self,
params: &DocContentControlsReplaceContentBoundParams,
) -> Result<DocContentControlsReplaceContentResult> {
self.replace_content_with_options(params, InvokeOptions::default())
.await
}
pub async fn replace_content_with_options(
&self,
params: &DocContentControlsReplaceContentBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsReplaceContentResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.replaceContent", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.replaceContent".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn select_by_tag(
&self,
params: &DocContentControlsSelectByTagBoundParams,
) -> Result<DocContentControlsSelectByTagResult> {
self.select_by_tag_with_options(params, InvokeOptions::default())
.await
}
pub async fn select_by_tag_with_options(
&self,
params: &DocContentControlsSelectByTagBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsSelectByTagResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.selectByTag", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.selectByTag".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn select_by_title(
&self,
params: &DocContentControlsSelectByTitleBoundParams,
) -> Result<DocContentControlsSelectByTitleResult> {
self.select_by_title_with_options(params, InvokeOptions::default())
.await
}
pub async fn select_by_title_with_options(
&self,
params: &DocContentControlsSelectByTitleBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsSelectByTitleResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.selectByTitle", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.selectByTitle".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn set_binding(
&self,
params: &DocContentControlsSetBindingBoundParams,
) -> Result<DocContentControlsSetBindingResult> {
self.set_binding_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_binding_with_options(
&self,
params: &DocContentControlsSetBindingBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsSetBindingResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.setBinding", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.setBinding".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_lock_mode(
&self,
params: &DocContentControlsSetLockModeBoundParams,
) -> Result<DocContentControlsSetLockModeResult> {
self.set_lock_mode_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_lock_mode_with_options(
&self,
params: &DocContentControlsSetLockModeBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsSetLockModeResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.setLockMode", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.setLockMode".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_type(
&self,
params: &DocContentControlsSetTypeBoundParams,
) -> Result<DocContentControlsSetTypeResult> {
self.set_type_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_type_with_options(
&self,
params: &DocContentControlsSetTypeBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsSetTypeResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.setType", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.setType".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn unwrap(
&self,
params: &DocContentControlsUnwrapBoundParams,
) -> Result<DocContentControlsUnwrapResult> {
self.unwrap_with_options(params, InvokeOptions::default())
.await
}
pub async fn unwrap_with_options(
&self,
params: &DocContentControlsUnwrapBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsUnwrapResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.unwrap", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.unwrap".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn validate_word_compatibility(
&self,
params: &DocContentControlsValidateWordCompatibilityBoundParams,
) -> Result<DocContentControlsValidateWordCompatibilityResult> {
self.validate_word_compatibility_with_options(params, InvokeOptions::default())
.await
}
pub async fn validate_word_compatibility_with_options(
&self,
params: &DocContentControlsValidateWordCompatibilityBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsValidateWordCompatibilityResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke(
"doc.contentControls.validateWordCompatibility",
params,
options,
)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.validateWordCompatibility".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn wrap(
&self,
params: &DocContentControlsWrapBoundParams,
) -> Result<DocContentControlsWrapResult> {
self.wrap_with_options(params, InvokeOptions::default())
.await
}
pub async fn wrap_with_options(
&self,
params: &DocContentControlsWrapBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsWrapResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.wrap", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.wrap".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiContentControlsCheckbox<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiContentControlsCheckbox<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn get_state(
&self,
params: &DocContentControlsCheckboxGetStateBoundParams,
) -> Result<DocContentControlsCheckboxGetStateResult> {
self.get_state_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_state_with_options(
&self,
params: &DocContentControlsCheckboxGetStateBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsCheckboxGetStateResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.checkbox.getState", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.checkbox.getState".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn set_state(
&self,
params: &DocContentControlsCheckboxSetStateBoundParams,
) -> Result<DocContentControlsCheckboxSetStateResult> {
self.set_state_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_state_with_options(
&self,
params: &DocContentControlsCheckboxSetStateBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsCheckboxSetStateResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.checkbox.setState", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.checkbox.setState".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_symbol_pair(
&self,
params: &DocContentControlsCheckboxSetSymbolPairBoundParams,
) -> Result<DocContentControlsCheckboxSetSymbolPairResult> {
self.set_symbol_pair_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_symbol_pair_with_options(
&self,
params: &DocContentControlsCheckboxSetSymbolPairBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsCheckboxSetSymbolPairResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke(
"doc.contentControls.checkbox.setSymbolPair",
params,
options,
)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.checkbox.setSymbolPair".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn toggle(
&self,
params: &DocContentControlsCheckboxToggleBoundParams,
) -> Result<DocContentControlsCheckboxToggleResult> {
self.toggle_with_options(params, InvokeOptions::default())
.await
}
pub async fn toggle_with_options(
&self,
params: &DocContentControlsCheckboxToggleBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsCheckboxToggleResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.checkbox.toggle", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.checkbox.toggle".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiContentControlsChoiceList<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiContentControlsChoiceList<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn get_items(
&self,
params: &DocContentControlsChoiceListGetItemsBoundParams,
) -> Result<DocContentControlsChoiceListGetItemsResult> {
self.get_items_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_items_with_options(
&self,
params: &DocContentControlsChoiceListGetItemsBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsChoiceListGetItemsResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.choiceList.getItems", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.choiceList.getItems".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn set_items(
&self,
params: &DocContentControlsChoiceListSetItemsBoundParams,
) -> Result<DocContentControlsChoiceListSetItemsResult> {
self.set_items_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_items_with_options(
&self,
params: &DocContentControlsChoiceListSetItemsBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsChoiceListSetItemsResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.choiceList.setItems", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.choiceList.setItems".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_selected(
&self,
params: &DocContentControlsChoiceListSetSelectedBoundParams,
) -> Result<DocContentControlsChoiceListSetSelectedResult> {
self.set_selected_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_selected_with_options(
&self,
params: &DocContentControlsChoiceListSetSelectedBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsChoiceListSetSelectedResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke(
"doc.contentControls.choiceList.setSelected",
params,
options,
)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.choiceList.setSelected".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiContentControlsDate<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiContentControlsDate<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn clear_value(
&self,
params: &DocContentControlsDateClearValueBoundParams,
) -> Result<DocContentControlsDateClearValueResult> {
self.clear_value_with_options(params, InvokeOptions::default())
.await
}
pub async fn clear_value_with_options(
&self,
params: &DocContentControlsDateClearValueBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsDateClearValueResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.date.clearValue", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.date.clearValue".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_calendar(
&self,
params: &DocContentControlsDateSetCalendarBoundParams,
) -> Result<DocContentControlsDateSetCalendarResult> {
self.set_calendar_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_calendar_with_options(
&self,
params: &DocContentControlsDateSetCalendarBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsDateSetCalendarResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.date.setCalendar", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.date.setCalendar".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_display_format(
&self,
params: &DocContentControlsDateSetDisplayFormatBoundParams,
) -> Result<DocContentControlsDateSetDisplayFormatResult> {
self.set_display_format_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_display_format_with_options(
&self,
params: &DocContentControlsDateSetDisplayFormatBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsDateSetDisplayFormatResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.date.setDisplayFormat", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.date.setDisplayFormat".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_display_locale(
&self,
params: &DocContentControlsDateSetDisplayLocaleBoundParams,
) -> Result<DocContentControlsDateSetDisplayLocaleResult> {
self.set_display_locale_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_display_locale_with_options(
&self,
params: &DocContentControlsDateSetDisplayLocaleBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsDateSetDisplayLocaleResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.date.setDisplayLocale", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.date.setDisplayLocale".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_storage_format(
&self,
params: &DocContentControlsDateSetStorageFormatBoundParams,
) -> Result<DocContentControlsDateSetStorageFormatResult> {
self.set_storage_format_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_storage_format_with_options(
&self,
params: &DocContentControlsDateSetStorageFormatBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsDateSetStorageFormatResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.date.setStorageFormat", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.date.setStorageFormat".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_value(
&self,
params: &DocContentControlsDateSetValueBoundParams,
) -> Result<DocContentControlsDateSetValueResult> {
self.set_value_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_value_with_options(
&self,
params: &DocContentControlsDateSetValueBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsDateSetValueResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.date.setValue", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.date.setValue".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiContentControlsGroup<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiContentControlsGroup<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn ungroup(
&self,
params: &DocContentControlsGroupUngroupBoundParams,
) -> Result<DocContentControlsGroupUngroupResult> {
self.ungroup_with_options(params, InvokeOptions::default())
.await
}
pub async fn ungroup_with_options(
&self,
params: &DocContentControlsGroupUngroupBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsGroupUngroupResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.group.ungroup", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.group.ungroup".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn wrap(
&self,
params: &DocContentControlsGroupWrapBoundParams,
) -> Result<DocContentControlsGroupWrapResult> {
self.wrap_with_options(params, InvokeOptions::default())
.await
}
pub async fn wrap_with_options(
&self,
params: &DocContentControlsGroupWrapBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsGroupWrapResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.group.wrap", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.group.wrap".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiContentControlsRepeatingSection<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiContentControlsRepeatingSection<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn clone_item(
&self,
params: &DocContentControlsRepeatingSectionCloneItemBoundParams,
) -> Result<DocContentControlsRepeatingSectionCloneItemResult> {
self.clone_item_with_options(params, InvokeOptions::default())
.await
}
pub async fn clone_item_with_options(
&self,
params: &DocContentControlsRepeatingSectionCloneItemBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsRepeatingSectionCloneItemResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke(
"doc.contentControls.repeatingSection.cloneItem",
params,
options,
)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.repeatingSection.cloneItem".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn delete_item(
&self,
params: &DocContentControlsRepeatingSectionDeleteItemBoundParams,
) -> Result<DocContentControlsRepeatingSectionDeleteItemResult> {
self.delete_item_with_options(params, InvokeOptions::default())
.await
}
pub async fn delete_item_with_options(
&self,
params: &DocContentControlsRepeatingSectionDeleteItemBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsRepeatingSectionDeleteItemResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke(
"doc.contentControls.repeatingSection.deleteItem",
params,
options,
)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.repeatingSection.deleteItem".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn insert_item_after(
&self,
params: &DocContentControlsRepeatingSectionInsertItemAfterBoundParams,
) -> Result<DocContentControlsRepeatingSectionInsertItemAfterResult> {
self.insert_item_after_with_options(params, InvokeOptions::default())
.await
}
pub async fn insert_item_after_with_options(
&self,
params: &DocContentControlsRepeatingSectionInsertItemAfterBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsRepeatingSectionInsertItemAfterResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke(
"doc.contentControls.repeatingSection.insertItemAfter",
params,
options,
)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id =
Some("doc.contentControls.repeatingSection.insertItemAfter".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn insert_item_before(
&self,
params: &DocContentControlsRepeatingSectionInsertItemBeforeBoundParams,
) -> Result<DocContentControlsRepeatingSectionInsertItemBeforeResult> {
self.insert_item_before_with_options(params, InvokeOptions::default())
.await
}
pub async fn insert_item_before_with_options(
&self,
params: &DocContentControlsRepeatingSectionInsertItemBeforeBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsRepeatingSectionInsertItemBeforeResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke(
"doc.contentControls.repeatingSection.insertItemBefore",
params,
options,
)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id =
Some("doc.contentControls.repeatingSection.insertItemBefore".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn list_items(
&self,
params: &DocContentControlsRepeatingSectionListItemsBoundParams,
) -> Result<DocContentControlsRepeatingSectionListItemsResult> {
self.list_items_with_options(params, InvokeOptions::default())
.await
}
pub async fn list_items_with_options(
&self,
params: &DocContentControlsRepeatingSectionListItemsBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsRepeatingSectionListItemsResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke(
"doc.contentControls.repeatingSection.listItems",
params,
options,
)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.repeatingSection.listItems".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn set_allow_insert_delete(
&self,
params: &DocContentControlsRepeatingSectionSetAllowInsertDeleteBoundParams,
) -> Result<DocContentControlsRepeatingSectionSetAllowInsertDeleteResult> {
self.set_allow_insert_delete_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_allow_insert_delete_with_options(
&self,
params: &DocContentControlsRepeatingSectionSetAllowInsertDeleteBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsRepeatingSectionSetAllowInsertDeleteResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke(
"doc.contentControls.repeatingSection.setAllowInsertDelete",
params,
options,
)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id =
Some("doc.contentControls.repeatingSection.setAllowInsertDelete".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiContentControlsText<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiContentControlsText<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn clear_value(
&self,
params: &DocContentControlsTextClearValueBoundParams,
) -> Result<DocContentControlsTextClearValueResult> {
self.clear_value_with_options(params, InvokeOptions::default())
.await
}
pub async fn clear_value_with_options(
&self,
params: &DocContentControlsTextClearValueBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsTextClearValueResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.text.clearValue", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.text.clearValue".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_multiline(
&self,
params: &DocContentControlsTextSetMultilineBoundParams,
) -> Result<DocContentControlsTextSetMultilineResult> {
self.set_multiline_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_multiline_with_options(
&self,
params: &DocContentControlsTextSetMultilineBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsTextSetMultilineResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.text.setMultiline", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.text.setMultiline".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_value(
&self,
params: &DocContentControlsTextSetValueBoundParams,
) -> Result<DocContentControlsTextSetValueResult> {
self.set_value_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_value_with_options(
&self,
params: &DocContentControlsTextSetValueBoundParams,
options: InvokeOptions,
) -> Result<DocContentControlsTextSetValueResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.contentControls.text.setValue", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.contentControls.text.setValue".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiCreate<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiCreate<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn content_control(
&self,
params: &DocCreateContentControlBoundParams,
) -> Result<DocCreateContentControlResult> {
self.content_control_with_options(params, InvokeOptions::default())
.await
}
pub async fn content_control_with_options(
&self,
params: &DocCreateContentControlBoundParams,
options: InvokeOptions,
) -> Result<DocCreateContentControlResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.create.contentControl", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.create.contentControl".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn heading(
&self,
params: &DocCreateHeadingBoundParams,
) -> Result<DocCreateHeadingResult> {
self.heading_with_options(params, InvokeOptions::default())
.await
}
pub async fn heading_with_options(
&self,
params: &DocCreateHeadingBoundParams,
options: InvokeOptions,
) -> Result<DocCreateHeadingResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.create.heading", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.create.heading".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn image(&self, params: &DocCreateImageBoundParams) -> Result<DocCreateImageResult> {
self.image_with_options(params, InvokeOptions::default())
.await
}
pub async fn image_with_options(
&self,
params: &DocCreateImageBoundParams,
options: InvokeOptions,
) -> Result<DocCreateImageResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.create.image", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.create.image".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn paragraph(
&self,
params: &DocCreateParagraphBoundParams,
) -> Result<DocCreateParagraphResult> {
self.paragraph_with_options(params, InvokeOptions::default())
.await
}
pub async fn paragraph_with_options(
&self,
params: &DocCreateParagraphBoundParams,
options: InvokeOptions,
) -> Result<DocCreateParagraphResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.create.paragraph", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.create.paragraph".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn section_break(
&self,
params: &DocCreateSectionBreakBoundParams,
) -> Result<DocCreateSectionBreakResult> {
self.section_break_with_options(params, InvokeOptions::default())
.await
}
pub async fn section_break_with_options(
&self,
params: &DocCreateSectionBreakBoundParams,
options: InvokeOptions,
) -> Result<DocCreateSectionBreakResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.create.sectionBreak", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.create.sectionBreak".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn table(&self, params: &DocCreateTableBoundParams) -> Result<DocCreateTableResult> {
self.table_with_options(params, InvokeOptions::default())
.await
}
pub async fn table_with_options(
&self,
params: &DocCreateTableBoundParams,
options: InvokeOptions,
) -> Result<DocCreateTableResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.create.table", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.create.table".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn table_of_contents(
&self,
params: &DocCreateTableOfContentsBoundParams,
) -> Result<DocCreateTableOfContentsResult> {
self.table_of_contents_with_options(params, InvokeOptions::default())
.await
}
pub async fn table_of_contents_with_options(
&self,
params: &DocCreateTableOfContentsBoundParams,
options: InvokeOptions,
) -> Result<DocCreateTableOfContentsResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.create.tableOfContents", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.create.tableOfContents".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiCrossRefs<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiCrossRefs<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn get(&self, params: &DocCrossRefsGetBoundParams) -> Result<DocCrossRefsGetResult> {
self.get_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_with_options(
&self,
params: &DocCrossRefsGetBoundParams,
options: InvokeOptions,
) -> Result<DocCrossRefsGetResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.crossRefs.get", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.crossRefs.get".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn insert(
&self,
params: &DocCrossRefsInsertBoundParams,
) -> Result<DocCrossRefsInsertResult> {
self.insert_with_options(params, InvokeOptions::default())
.await
}
pub async fn insert_with_options(
&self,
params: &DocCrossRefsInsertBoundParams,
options: InvokeOptions,
) -> Result<DocCrossRefsInsertResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.crossRefs.insert", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.crossRefs.insert".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn list(
&self,
params: &DocCrossRefsListBoundParams,
) -> Result<DocCrossRefsListResult> {
self.list_with_options(params, InvokeOptions::default())
.await
}
pub async fn list_with_options(
&self,
params: &DocCrossRefsListBoundParams,
options: InvokeOptions,
) -> Result<DocCrossRefsListResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.crossRefs.list", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.crossRefs.list".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn rebuild(
&self,
params: &DocCrossRefsRebuildBoundParams,
) -> Result<DocCrossRefsRebuildResult> {
self.rebuild_with_options(params, InvokeOptions::default())
.await
}
pub async fn rebuild_with_options(
&self,
params: &DocCrossRefsRebuildBoundParams,
options: InvokeOptions,
) -> Result<DocCrossRefsRebuildResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.crossRefs.rebuild", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.crossRefs.rebuild".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn remove(
&self,
params: &DocCrossRefsRemoveBoundParams,
) -> Result<DocCrossRefsRemoveResult> {
self.remove_with_options(params, InvokeOptions::default())
.await
}
pub async fn remove_with_options(
&self,
params: &DocCrossRefsRemoveBoundParams,
options: InvokeOptions,
) -> Result<DocCrossRefsRemoveResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.crossRefs.remove", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.crossRefs.remove".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiCustomXml<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiCustomXml<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub fn parts(&self) -> DocApiCustomXmlParts<'a, I> {
DocApiCustomXmlParts::new(self.invoker)
}
}
pub struct DocApiCustomXmlParts<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiCustomXmlParts<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn create(
&self,
params: &DocCustomXmlPartsCreateBoundParams,
) -> Result<DocCustomXmlPartsCreateResult> {
self.create_with_options(params, InvokeOptions::default())
.await
}
pub async fn create_with_options(
&self,
params: &DocCustomXmlPartsCreateBoundParams,
options: InvokeOptions,
) -> Result<DocCustomXmlPartsCreateResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.customXml.parts.create", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.customXml.parts.create".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn get(
&self,
params: &DocCustomXmlPartsGetBoundParams,
) -> Result<DocCustomXmlPartsGetResult> {
self.get_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_with_options(
&self,
params: &DocCustomXmlPartsGetBoundParams,
options: InvokeOptions,
) -> Result<DocCustomXmlPartsGetResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.customXml.parts.get", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.customXml.parts.get".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn list(
&self,
params: &DocCustomXmlPartsListBoundParams,
) -> Result<DocCustomXmlPartsListResult> {
self.list_with_options(params, InvokeOptions::default())
.await
}
pub async fn list_with_options(
&self,
params: &DocCustomXmlPartsListBoundParams,
options: InvokeOptions,
) -> Result<DocCustomXmlPartsListResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.customXml.parts.list", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.customXml.parts.list".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn patch(
&self,
params: &DocCustomXmlPartsPatchBoundParams,
) -> Result<DocCustomXmlPartsPatchResult> {
self.patch_with_options(params, InvokeOptions::default())
.await
}
pub async fn patch_with_options(
&self,
params: &DocCustomXmlPartsPatchBoundParams,
options: InvokeOptions,
) -> Result<DocCustomXmlPartsPatchResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.customXml.parts.patch", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.customXml.parts.patch".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn remove(
&self,
params: &DocCustomXmlPartsRemoveBoundParams,
) -> Result<DocCustomXmlPartsRemoveResult> {
self.remove_with_options(params, InvokeOptions::default())
.await
}
pub async fn remove_with_options(
&self,
params: &DocCustomXmlPartsRemoveBoundParams,
options: InvokeOptions,
) -> Result<DocCustomXmlPartsRemoveResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.customXml.parts.remove", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.customXml.parts.remove".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiDiff<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiDiff<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn apply(&self, params: &DocDiffApplyBoundParams) -> Result<DocDiffApplyResult> {
self.apply_with_options(params, InvokeOptions::default())
.await
}
pub async fn apply_with_options(
&self,
params: &DocDiffApplyBoundParams,
options: InvokeOptions,
) -> Result<DocDiffApplyResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.diff.apply", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.diff.apply".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn capture(
&self,
params: &DocDiffCaptureBoundParams,
) -> Result<DocDiffCaptureResult> {
self.capture_with_options(params, InvokeOptions::default())
.await
}
pub async fn capture_with_options(
&self,
params: &DocDiffCaptureBoundParams,
options: InvokeOptions,
) -> Result<DocDiffCaptureResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.diff.capture", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.diff.capture".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn compare(
&self,
params: &DocDiffCompareBoundParams,
) -> Result<DocDiffCompareResult> {
self.compare_with_options(params, InvokeOptions::default())
.await
}
pub async fn compare_with_options(
&self,
params: &DocDiffCompareBoundParams,
options: InvokeOptions,
) -> Result<DocDiffCompareResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.diff.compare", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.diff.compare".to_owned());
error.outcome_unknown = false;
error
})
}
}
pub struct DocApiExport<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiExport<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn to_docx(
&self,
params: &DocExportToDocxBoundParams,
) -> Result<DocExportToDocxResult> {
self.to_docx_with_options(params, InvokeOptions::default())
.await
}
pub async fn to_docx_with_options(
&self,
params: &DocExportToDocxBoundParams,
options: InvokeOptions,
) -> Result<DocExportToDocxResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.export.toDocx", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.export.toDocx".to_owned());
error.outcome_unknown = false;
error
})
}
}
pub struct DocApiFields<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiFields<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn get(&self, params: &DocFieldsGetBoundParams) -> Result<DocFieldsGetResult> {
self.get_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_with_options(
&self,
params: &DocFieldsGetBoundParams,
options: InvokeOptions,
) -> Result<DocFieldsGetResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.fields.get", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.fields.get".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn insert(
&self,
params: &DocFieldsInsertBoundParams,
) -> Result<DocFieldsInsertResult> {
self.insert_with_options(params, InvokeOptions::default())
.await
}
pub async fn insert_with_options(
&self,
params: &DocFieldsInsertBoundParams,
options: InvokeOptions,
) -> Result<DocFieldsInsertResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.fields.insert", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.fields.insert".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn list(&self, params: &DocFieldsListBoundParams) -> Result<DocFieldsListResult> {
self.list_with_options(params, InvokeOptions::default())
.await
}
pub async fn list_with_options(
&self,
params: &DocFieldsListBoundParams,
options: InvokeOptions,
) -> Result<DocFieldsListResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.fields.list", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.fields.list".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn rebuild(
&self,
params: &DocFieldsRebuildBoundParams,
) -> Result<DocFieldsRebuildResult> {
self.rebuild_with_options(params, InvokeOptions::default())
.await
}
pub async fn rebuild_with_options(
&self,
params: &DocFieldsRebuildBoundParams,
options: InvokeOptions,
) -> Result<DocFieldsRebuildResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.fields.rebuild", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.fields.rebuild".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn remove(
&self,
params: &DocFieldsRemoveBoundParams,
) -> Result<DocFieldsRemoveResult> {
self.remove_with_options(params, InvokeOptions::default())
.await
}
pub async fn remove_with_options(
&self,
params: &DocFieldsRemoveBoundParams,
options: InvokeOptions,
) -> Result<DocFieldsRemoveResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.fields.remove", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.fields.remove".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiFootnotes<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiFootnotes<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn configure(
&self,
params: &DocFootnotesConfigureBoundParams,
) -> Result<DocFootnotesConfigureResult> {
self.configure_with_options(params, InvokeOptions::default())
.await
}
pub async fn configure_with_options(
&self,
params: &DocFootnotesConfigureBoundParams,
options: InvokeOptions,
) -> Result<DocFootnotesConfigureResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.footnotes.configure", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.footnotes.configure".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn get(&self, params: &DocFootnotesGetBoundParams) -> Result<DocFootnotesGetResult> {
self.get_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_with_options(
&self,
params: &DocFootnotesGetBoundParams,
options: InvokeOptions,
) -> Result<DocFootnotesGetResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.footnotes.get", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.footnotes.get".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn insert(
&self,
params: &DocFootnotesInsertBoundParams,
) -> Result<DocFootnotesInsertResult> {
self.insert_with_options(params, InvokeOptions::default())
.await
}
pub async fn insert_with_options(
&self,
params: &DocFootnotesInsertBoundParams,
options: InvokeOptions,
) -> Result<DocFootnotesInsertResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.footnotes.insert", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.footnotes.insert".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn list(
&self,
params: &DocFootnotesListBoundParams,
) -> Result<DocFootnotesListResult> {
self.list_with_options(params, InvokeOptions::default())
.await
}
pub async fn list_with_options(
&self,
params: &DocFootnotesListBoundParams,
options: InvokeOptions,
) -> Result<DocFootnotesListResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.footnotes.list", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.footnotes.list".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn remove(
&self,
params: &DocFootnotesRemoveBoundParams,
) -> Result<DocFootnotesRemoveResult> {
self.remove_with_options(params, InvokeOptions::default())
.await
}
pub async fn remove_with_options(
&self,
params: &DocFootnotesRemoveBoundParams,
options: InvokeOptions,
) -> Result<DocFootnotesRemoveResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.footnotes.remove", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.footnotes.remove".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn update(
&self,
params: &DocFootnotesUpdateBoundParams,
) -> Result<DocFootnotesUpdateResult> {
self.update_with_options(params, InvokeOptions::default())
.await
}
pub async fn update_with_options(
&self,
params: &DocFootnotesUpdateBoundParams,
options: InvokeOptions,
) -> Result<DocFootnotesUpdateResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.footnotes.update", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.footnotes.update".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiFormat<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiFormat<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub fn paragraph(&self) -> DocApiFormatParagraph<'a, I> {
DocApiFormatParagraph::new(self.invoker)
}
pub async fn apply(&self, params: &DocFormatApplyBoundParams) -> Result<DocFormatApplyResult> {
self.apply_with_options(params, InvokeOptions::default())
.await
}
pub async fn apply_with_options(
&self,
params: &DocFormatApplyBoundParams,
options: InvokeOptions,
) -> Result<DocFormatApplyResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.apply", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.apply".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn b_cs(&self, params: &DocFormatBCsBoundParams) -> Result<DocFormatBCsResult> {
self.b_cs_with_options(params, InvokeOptions::default())
.await
}
pub async fn b_cs_with_options(
&self,
params: &DocFormatBCsBoundParams,
options: InvokeOptions,
) -> Result<DocFormatBCsResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.bCs", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.bCs".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn bold(&self, params: &DocFormatBoldBoundParams) -> Result<DocFormatBoldResult> {
self.bold_with_options(params, InvokeOptions::default())
.await
}
pub async fn bold_with_options(
&self,
params: &DocFormatBoldBoundParams,
options: InvokeOptions,
) -> Result<DocFormatBoldResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.bold", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.bold".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn border(
&self,
params: &DocFormatBorderBoundParams,
) -> Result<DocFormatBorderResult> {
self.border_with_options(params, InvokeOptions::default())
.await
}
pub async fn border_with_options(
&self,
params: &DocFormatBorderBoundParams,
options: InvokeOptions,
) -> Result<DocFormatBorderResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.border", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.border".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn caps(&self, params: &DocFormatCapsBoundParams) -> Result<DocFormatCapsResult> {
self.caps_with_options(params, InvokeOptions::default())
.await
}
pub async fn caps_with_options(
&self,
params: &DocFormatCapsBoundParams,
options: InvokeOptions,
) -> Result<DocFormatCapsResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.caps", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.caps".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn char_scale(
&self,
params: &DocFormatCharScaleBoundParams,
) -> Result<DocFormatCharScaleResult> {
self.char_scale_with_options(params, InvokeOptions::default())
.await
}
pub async fn char_scale_with_options(
&self,
params: &DocFormatCharScaleBoundParams,
options: InvokeOptions,
) -> Result<DocFormatCharScaleResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.charScale", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.charScale".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn color(&self, params: &DocFormatColorBoundParams) -> Result<DocFormatColorResult> {
self.color_with_options(params, InvokeOptions::default())
.await
}
pub async fn color_with_options(
&self,
params: &DocFormatColorBoundParams,
options: InvokeOptions,
) -> Result<DocFormatColorResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.color", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.color".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn contextual_alternates(
&self,
params: &DocFormatContextualAlternatesBoundParams,
) -> Result<DocFormatContextualAlternatesResult> {
self.contextual_alternates_with_options(params, InvokeOptions::default())
.await
}
pub async fn contextual_alternates_with_options(
&self,
params: &DocFormatContextualAlternatesBoundParams,
options: InvokeOptions,
) -> Result<DocFormatContextualAlternatesResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.contextualAlternates", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.contextualAlternates".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn cs(&self, params: &DocFormatCsBoundParams) -> Result<DocFormatCsResult> {
self.cs_with_options(params, InvokeOptions::default()).await
}
pub async fn cs_with_options(
&self,
params: &DocFormatCsBoundParams,
options: InvokeOptions,
) -> Result<DocFormatCsResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.cs", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.cs".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn dstrike(
&self,
params: &DocFormatDstrikeBoundParams,
) -> Result<DocFormatDstrikeResult> {
self.dstrike_with_options(params, InvokeOptions::default())
.await
}
pub async fn dstrike_with_options(
&self,
params: &DocFormatDstrikeBoundParams,
options: InvokeOptions,
) -> Result<DocFormatDstrikeResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.dstrike", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.dstrike".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn east_asian_layout(
&self,
params: &DocFormatEastAsianLayoutBoundParams,
) -> Result<DocFormatEastAsianLayoutResult> {
self.east_asian_layout_with_options(params, InvokeOptions::default())
.await
}
pub async fn east_asian_layout_with_options(
&self,
params: &DocFormatEastAsianLayoutBoundParams,
options: InvokeOptions,
) -> Result<DocFormatEastAsianLayoutResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.eastAsianLayout", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.eastAsianLayout".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn em(&self, params: &DocFormatEmBoundParams) -> Result<DocFormatEmResult> {
self.em_with_options(params, InvokeOptions::default()).await
}
pub async fn em_with_options(
&self,
params: &DocFormatEmBoundParams,
options: InvokeOptions,
) -> Result<DocFormatEmResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.em", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.em".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn emboss(
&self,
params: &DocFormatEmbossBoundParams,
) -> Result<DocFormatEmbossResult> {
self.emboss_with_options(params, InvokeOptions::default())
.await
}
pub async fn emboss_with_options(
&self,
params: &DocFormatEmbossBoundParams,
options: InvokeOptions,
) -> Result<DocFormatEmbossResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.emboss", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.emboss".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn fit_text(
&self,
params: &DocFormatFitTextBoundParams,
) -> Result<DocFormatFitTextResult> {
self.fit_text_with_options(params, InvokeOptions::default())
.await
}
pub async fn fit_text_with_options(
&self,
params: &DocFormatFitTextBoundParams,
options: InvokeOptions,
) -> Result<DocFormatFitTextResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.fitText", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.fitText".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn font_family(
&self,
params: &DocFormatFontFamilyBoundParams,
) -> Result<DocFormatFontFamilyResult> {
self.font_family_with_options(params, InvokeOptions::default())
.await
}
pub async fn font_family_with_options(
&self,
params: &DocFormatFontFamilyBoundParams,
options: InvokeOptions,
) -> Result<DocFormatFontFamilyResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.fontFamily", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.fontFamily".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn font_size(
&self,
params: &DocFormatFontSizeBoundParams,
) -> Result<DocFormatFontSizeResult> {
self.font_size_with_options(params, InvokeOptions::default())
.await
}
pub async fn font_size_with_options(
&self,
params: &DocFormatFontSizeBoundParams,
options: InvokeOptions,
) -> Result<DocFormatFontSizeResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.fontSize", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.fontSize".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn font_size_cs(
&self,
params: &DocFormatFontSizeCsBoundParams,
) -> Result<DocFormatFontSizeCsResult> {
self.font_size_cs_with_options(params, InvokeOptions::default())
.await
}
pub async fn font_size_cs_with_options(
&self,
params: &DocFormatFontSizeCsBoundParams,
options: InvokeOptions,
) -> Result<DocFormatFontSizeCsResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.fontSizeCs", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.fontSizeCs".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn highlight(
&self,
params: &DocFormatHighlightBoundParams,
) -> Result<DocFormatHighlightResult> {
self.highlight_with_options(params, InvokeOptions::default())
.await
}
pub async fn highlight_with_options(
&self,
params: &DocFormatHighlightBoundParams,
options: InvokeOptions,
) -> Result<DocFormatHighlightResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.highlight", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.highlight".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn i_cs(&self, params: &DocFormatICsBoundParams) -> Result<DocFormatICsResult> {
self.i_cs_with_options(params, InvokeOptions::default())
.await
}
pub async fn i_cs_with_options(
&self,
params: &DocFormatICsBoundParams,
options: InvokeOptions,
) -> Result<DocFormatICsResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.iCs", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.iCs".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn imprint(
&self,
params: &DocFormatImprintBoundParams,
) -> Result<DocFormatImprintResult> {
self.imprint_with_options(params, InvokeOptions::default())
.await
}
pub async fn imprint_with_options(
&self,
params: &DocFormatImprintBoundParams,
options: InvokeOptions,
) -> Result<DocFormatImprintResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.imprint", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.imprint".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn italic(
&self,
params: &DocFormatItalicBoundParams,
) -> Result<DocFormatItalicResult> {
self.italic_with_options(params, InvokeOptions::default())
.await
}
pub async fn italic_with_options(
&self,
params: &DocFormatItalicBoundParams,
options: InvokeOptions,
) -> Result<DocFormatItalicResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.italic", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.italic".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn kerning(
&self,
params: &DocFormatKerningBoundParams,
) -> Result<DocFormatKerningResult> {
self.kerning_with_options(params, InvokeOptions::default())
.await
}
pub async fn kerning_with_options(
&self,
params: &DocFormatKerningBoundParams,
options: InvokeOptions,
) -> Result<DocFormatKerningResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.kerning", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.kerning".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn lang(&self, params: &DocFormatLangBoundParams) -> Result<DocFormatLangResult> {
self.lang_with_options(params, InvokeOptions::default())
.await
}
pub async fn lang_with_options(
&self,
params: &DocFormatLangBoundParams,
options: InvokeOptions,
) -> Result<DocFormatLangResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.lang", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.lang".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn letter_spacing(
&self,
params: &DocFormatLetterSpacingBoundParams,
) -> Result<DocFormatLetterSpacingResult> {
self.letter_spacing_with_options(params, InvokeOptions::default())
.await
}
pub async fn letter_spacing_with_options(
&self,
params: &DocFormatLetterSpacingBoundParams,
options: InvokeOptions,
) -> Result<DocFormatLetterSpacingResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.letterSpacing", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.letterSpacing".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn ligatures(
&self,
params: &DocFormatLigaturesBoundParams,
) -> Result<DocFormatLigaturesResult> {
self.ligatures_with_options(params, InvokeOptions::default())
.await
}
pub async fn ligatures_with_options(
&self,
params: &DocFormatLigaturesBoundParams,
options: InvokeOptions,
) -> Result<DocFormatLigaturesResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.ligatures", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.ligatures".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn num_form(
&self,
params: &DocFormatNumFormBoundParams,
) -> Result<DocFormatNumFormResult> {
self.num_form_with_options(params, InvokeOptions::default())
.await
}
pub async fn num_form_with_options(
&self,
params: &DocFormatNumFormBoundParams,
options: InvokeOptions,
) -> Result<DocFormatNumFormResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.numForm", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.numForm".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn num_spacing(
&self,
params: &DocFormatNumSpacingBoundParams,
) -> Result<DocFormatNumSpacingResult> {
self.num_spacing_with_options(params, InvokeOptions::default())
.await
}
pub async fn num_spacing_with_options(
&self,
params: &DocFormatNumSpacingBoundParams,
options: InvokeOptions,
) -> Result<DocFormatNumSpacingResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.numSpacing", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.numSpacing".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn o_math(&self, params: &DocFormatOMathBoundParams) -> Result<DocFormatOMathResult> {
self.o_math_with_options(params, InvokeOptions::default())
.await
}
pub async fn o_math_with_options(
&self,
params: &DocFormatOMathBoundParams,
options: InvokeOptions,
) -> Result<DocFormatOMathResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.oMath", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.oMath".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn outline(
&self,
params: &DocFormatOutlineBoundParams,
) -> Result<DocFormatOutlineResult> {
self.outline_with_options(params, InvokeOptions::default())
.await
}
pub async fn outline_with_options(
&self,
params: &DocFormatOutlineBoundParams,
options: InvokeOptions,
) -> Result<DocFormatOutlineResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.outline", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.outline".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn position(
&self,
params: &DocFormatPositionBoundParams,
) -> Result<DocFormatPositionResult> {
self.position_with_options(params, InvokeOptions::default())
.await
}
pub async fn position_with_options(
&self,
params: &DocFormatPositionBoundParams,
options: InvokeOptions,
) -> Result<DocFormatPositionResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.position", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.position".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn r_fonts(
&self,
params: &DocFormatRFontsBoundParams,
) -> Result<DocFormatRFontsResult> {
self.r_fonts_with_options(params, InvokeOptions::default())
.await
}
pub async fn r_fonts_with_options(
&self,
params: &DocFormatRFontsBoundParams,
options: InvokeOptions,
) -> Result<DocFormatRFontsResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.rFonts", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.rFonts".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn r_style(
&self,
params: &DocFormatRStyleBoundParams,
) -> Result<DocFormatRStyleResult> {
self.r_style_with_options(params, InvokeOptions::default())
.await
}
pub async fn r_style_with_options(
&self,
params: &DocFormatRStyleBoundParams,
options: InvokeOptions,
) -> Result<DocFormatRStyleResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.rStyle", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.rStyle".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn rtl(&self, params: &DocFormatRtlBoundParams) -> Result<DocFormatRtlResult> {
self.rtl_with_options(params, InvokeOptions::default())
.await
}
pub async fn rtl_with_options(
&self,
params: &DocFormatRtlBoundParams,
options: InvokeOptions,
) -> Result<DocFormatRtlResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.rtl", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.rtl".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn shading(
&self,
params: &DocFormatShadingBoundParams,
) -> Result<DocFormatShadingResult> {
self.shading_with_options(params, InvokeOptions::default())
.await
}
pub async fn shading_with_options(
&self,
params: &DocFormatShadingBoundParams,
options: InvokeOptions,
) -> Result<DocFormatShadingResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.shading", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.shading".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn shadow(
&self,
params: &DocFormatShadowBoundParams,
) -> Result<DocFormatShadowResult> {
self.shadow_with_options(params, InvokeOptions::default())
.await
}
pub async fn shadow_with_options(
&self,
params: &DocFormatShadowBoundParams,
options: InvokeOptions,
) -> Result<DocFormatShadowResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.shadow", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.shadow".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn small_caps(
&self,
params: &DocFormatSmallCapsBoundParams,
) -> Result<DocFormatSmallCapsResult> {
self.small_caps_with_options(params, InvokeOptions::default())
.await
}
pub async fn small_caps_with_options(
&self,
params: &DocFormatSmallCapsBoundParams,
options: InvokeOptions,
) -> Result<DocFormatSmallCapsResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.smallCaps", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.smallCaps".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn snap_to_grid(
&self,
params: &DocFormatSnapToGridBoundParams,
) -> Result<DocFormatSnapToGridResult> {
self.snap_to_grid_with_options(params, InvokeOptions::default())
.await
}
pub async fn snap_to_grid_with_options(
&self,
params: &DocFormatSnapToGridBoundParams,
options: InvokeOptions,
) -> Result<DocFormatSnapToGridResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.snapToGrid", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.snapToGrid".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn spec_vanish(
&self,
params: &DocFormatSpecVanishBoundParams,
) -> Result<DocFormatSpecVanishResult> {
self.spec_vanish_with_options(params, InvokeOptions::default())
.await
}
pub async fn spec_vanish_with_options(
&self,
params: &DocFormatSpecVanishBoundParams,
options: InvokeOptions,
) -> Result<DocFormatSpecVanishResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.specVanish", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.specVanish".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn strike(
&self,
params: &DocFormatStrikeBoundParams,
) -> Result<DocFormatStrikeResult> {
self.strike_with_options(params, InvokeOptions::default())
.await
}
pub async fn strike_with_options(
&self,
params: &DocFormatStrikeBoundParams,
options: InvokeOptions,
) -> Result<DocFormatStrikeResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.strike", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.strike".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn stylistic_sets(
&self,
params: &DocFormatStylisticSetsBoundParams,
) -> Result<DocFormatStylisticSetsResult> {
self.stylistic_sets_with_options(params, InvokeOptions::default())
.await
}
pub async fn stylistic_sets_with_options(
&self,
params: &DocFormatStylisticSetsBoundParams,
options: InvokeOptions,
) -> Result<DocFormatStylisticSetsResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.stylisticSets", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.stylisticSets".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn underline(
&self,
params: &DocFormatUnderlineBoundParams,
) -> Result<DocFormatUnderlineResult> {
self.underline_with_options(params, InvokeOptions::default())
.await
}
pub async fn underline_with_options(
&self,
params: &DocFormatUnderlineBoundParams,
options: InvokeOptions,
) -> Result<DocFormatUnderlineResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.underline", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.underline".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn vanish(
&self,
params: &DocFormatVanishBoundParams,
) -> Result<DocFormatVanishResult> {
self.vanish_with_options(params, InvokeOptions::default())
.await
}
pub async fn vanish_with_options(
&self,
params: &DocFormatVanishBoundParams,
options: InvokeOptions,
) -> Result<DocFormatVanishResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.vanish", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.vanish".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn vert_align(
&self,
params: &DocFormatVertAlignBoundParams,
) -> Result<DocFormatVertAlignResult> {
self.vert_align_with_options(params, InvokeOptions::default())
.await
}
pub async fn vert_align_with_options(
&self,
params: &DocFormatVertAlignBoundParams,
options: InvokeOptions,
) -> Result<DocFormatVertAlignResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.vertAlign", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.vertAlign".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn web_hidden(
&self,
params: &DocFormatWebHiddenBoundParams,
) -> Result<DocFormatWebHiddenResult> {
self.web_hidden_with_options(params, InvokeOptions::default())
.await
}
pub async fn web_hidden_with_options(
&self,
params: &DocFormatWebHiddenBoundParams,
options: InvokeOptions,
) -> Result<DocFormatWebHiddenResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.webHidden", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.webHidden".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiFormatParagraph<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiFormatParagraph<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn clear_alignment(
&self,
params: &DocFormatParagraphClearAlignmentBoundParams,
) -> Result<DocFormatParagraphClearAlignmentResult> {
self.clear_alignment_with_options(params, InvokeOptions::default())
.await
}
pub async fn clear_alignment_with_options(
&self,
params: &DocFormatParagraphClearAlignmentBoundParams,
options: InvokeOptions,
) -> Result<DocFormatParagraphClearAlignmentResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.paragraph.clearAlignment", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.paragraph.clearAlignment".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn clear_all_tab_stops(
&self,
params: &DocFormatParagraphClearAllTabStopsBoundParams,
) -> Result<DocFormatParagraphClearAllTabStopsResult> {
self.clear_all_tab_stops_with_options(params, InvokeOptions::default())
.await
}
pub async fn clear_all_tab_stops_with_options(
&self,
params: &DocFormatParagraphClearAllTabStopsBoundParams,
options: InvokeOptions,
) -> Result<DocFormatParagraphClearAllTabStopsResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.paragraph.clearAllTabStops", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.paragraph.clearAllTabStops".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn clear_border(
&self,
params: &DocFormatParagraphClearBorderBoundParams,
) -> Result<DocFormatParagraphClearBorderResult> {
self.clear_border_with_options(params, InvokeOptions::default())
.await
}
pub async fn clear_border_with_options(
&self,
params: &DocFormatParagraphClearBorderBoundParams,
options: InvokeOptions,
) -> Result<DocFormatParagraphClearBorderResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.paragraph.clearBorder", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.paragraph.clearBorder".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn clear_direction(
&self,
params: &DocFormatParagraphClearDirectionBoundParams,
) -> Result<DocFormatParagraphClearDirectionResult> {
self.clear_direction_with_options(params, InvokeOptions::default())
.await
}
pub async fn clear_direction_with_options(
&self,
params: &DocFormatParagraphClearDirectionBoundParams,
options: InvokeOptions,
) -> Result<DocFormatParagraphClearDirectionResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.paragraph.clearDirection", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.paragraph.clearDirection".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn clear_indentation(
&self,
params: &DocFormatParagraphClearIndentationBoundParams,
) -> Result<DocFormatParagraphClearIndentationResult> {
self.clear_indentation_with_options(params, InvokeOptions::default())
.await
}
pub async fn clear_indentation_with_options(
&self,
params: &DocFormatParagraphClearIndentationBoundParams,
options: InvokeOptions,
) -> Result<DocFormatParagraphClearIndentationResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.paragraph.clearIndentation", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.paragraph.clearIndentation".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn clear_shading(
&self,
params: &DocFormatParagraphClearShadingBoundParams,
) -> Result<DocFormatParagraphClearShadingResult> {
self.clear_shading_with_options(params, InvokeOptions::default())
.await
}
pub async fn clear_shading_with_options(
&self,
params: &DocFormatParagraphClearShadingBoundParams,
options: InvokeOptions,
) -> Result<DocFormatParagraphClearShadingResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.paragraph.clearShading", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.paragraph.clearShading".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn clear_spacing(
&self,
params: &DocFormatParagraphClearSpacingBoundParams,
) -> Result<DocFormatParagraphClearSpacingResult> {
self.clear_spacing_with_options(params, InvokeOptions::default())
.await
}
pub async fn clear_spacing_with_options(
&self,
params: &DocFormatParagraphClearSpacingBoundParams,
options: InvokeOptions,
) -> Result<DocFormatParagraphClearSpacingResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.paragraph.clearSpacing", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.paragraph.clearSpacing".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn clear_tab_stop(
&self,
params: &DocFormatParagraphClearTabStopBoundParams,
) -> Result<DocFormatParagraphClearTabStopResult> {
self.clear_tab_stop_with_options(params, InvokeOptions::default())
.await
}
pub async fn clear_tab_stop_with_options(
&self,
params: &DocFormatParagraphClearTabStopBoundParams,
options: InvokeOptions,
) -> Result<DocFormatParagraphClearTabStopResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.paragraph.clearTabStop", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.paragraph.clearTabStop".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn reset_direct_formatting(
&self,
params: &DocFormatParagraphResetDirectFormattingBoundParams,
) -> Result<DocFormatParagraphResetDirectFormattingResult> {
self.reset_direct_formatting_with_options(params, InvokeOptions::default())
.await
}
pub async fn reset_direct_formatting_with_options(
&self,
params: &DocFormatParagraphResetDirectFormattingBoundParams,
options: InvokeOptions,
) -> Result<DocFormatParagraphResetDirectFormattingResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke(
"doc.format.paragraph.resetDirectFormatting",
params,
options,
)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.paragraph.resetDirectFormatting".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_alignment(
&self,
params: &DocFormatParagraphSetAlignmentBoundParams,
) -> Result<DocFormatParagraphSetAlignmentResult> {
self.set_alignment_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_alignment_with_options(
&self,
params: &DocFormatParagraphSetAlignmentBoundParams,
options: InvokeOptions,
) -> Result<DocFormatParagraphSetAlignmentResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.paragraph.setAlignment", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.paragraph.setAlignment".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_border(
&self,
params: &DocFormatParagraphSetBorderBoundParams,
) -> Result<DocFormatParagraphSetBorderResult> {
self.set_border_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_border_with_options(
&self,
params: &DocFormatParagraphSetBorderBoundParams,
options: InvokeOptions,
) -> Result<DocFormatParagraphSetBorderResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.paragraph.setBorder", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.paragraph.setBorder".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_direction(
&self,
params: &DocFormatParagraphSetDirectionBoundParams,
) -> Result<DocFormatParagraphSetDirectionResult> {
self.set_direction_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_direction_with_options(
&self,
params: &DocFormatParagraphSetDirectionBoundParams,
options: InvokeOptions,
) -> Result<DocFormatParagraphSetDirectionResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.paragraph.setDirection", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.paragraph.setDirection".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_flow_options(
&self,
params: &DocFormatParagraphSetFlowOptionsBoundParams,
) -> Result<DocFormatParagraphSetFlowOptionsResult> {
self.set_flow_options_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_flow_options_with_options(
&self,
params: &DocFormatParagraphSetFlowOptionsBoundParams,
options: InvokeOptions,
) -> Result<DocFormatParagraphSetFlowOptionsResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.paragraph.setFlowOptions", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.paragraph.setFlowOptions".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_indentation(
&self,
params: &DocFormatParagraphSetIndentationBoundParams,
) -> Result<DocFormatParagraphSetIndentationResult> {
self.set_indentation_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_indentation_with_options(
&self,
params: &DocFormatParagraphSetIndentationBoundParams,
options: InvokeOptions,
) -> Result<DocFormatParagraphSetIndentationResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.paragraph.setIndentation", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.paragraph.setIndentation".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_keep_options(
&self,
params: &DocFormatParagraphSetKeepOptionsBoundParams,
) -> Result<DocFormatParagraphSetKeepOptionsResult> {
self.set_keep_options_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_keep_options_with_options(
&self,
params: &DocFormatParagraphSetKeepOptionsBoundParams,
options: InvokeOptions,
) -> Result<DocFormatParagraphSetKeepOptionsResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.paragraph.setKeepOptions", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.paragraph.setKeepOptions".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_mark_run_props(
&self,
params: &DocFormatParagraphSetMarkRunPropsBoundParams,
) -> Result<DocFormatParagraphSetMarkRunPropsResult> {
self.set_mark_run_props_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_mark_run_props_with_options(
&self,
params: &DocFormatParagraphSetMarkRunPropsBoundParams,
options: InvokeOptions,
) -> Result<DocFormatParagraphSetMarkRunPropsResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.paragraph.setMarkRunProps", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.paragraph.setMarkRunProps".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_numbering(
&self,
params: &DocFormatParagraphSetNumberingBoundParams,
) -> Result<DocFormatParagraphSetNumberingResult> {
self.set_numbering_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_numbering_with_options(
&self,
params: &DocFormatParagraphSetNumberingBoundParams,
options: InvokeOptions,
) -> Result<DocFormatParagraphSetNumberingResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.paragraph.setNumbering", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.paragraph.setNumbering".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_outline_level(
&self,
params: &DocFormatParagraphSetOutlineLevelBoundParams,
) -> Result<DocFormatParagraphSetOutlineLevelResult> {
self.set_outline_level_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_outline_level_with_options(
&self,
params: &DocFormatParagraphSetOutlineLevelBoundParams,
options: InvokeOptions,
) -> Result<DocFormatParagraphSetOutlineLevelResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.paragraph.setOutlineLevel", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.paragraph.setOutlineLevel".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_shading(
&self,
params: &DocFormatParagraphSetShadingBoundParams,
) -> Result<DocFormatParagraphSetShadingResult> {
self.set_shading_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_shading_with_options(
&self,
params: &DocFormatParagraphSetShadingBoundParams,
options: InvokeOptions,
) -> Result<DocFormatParagraphSetShadingResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.paragraph.setShading", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.paragraph.setShading".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_spacing(
&self,
params: &DocFormatParagraphSetSpacingBoundParams,
) -> Result<DocFormatParagraphSetSpacingResult> {
self.set_spacing_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_spacing_with_options(
&self,
params: &DocFormatParagraphSetSpacingBoundParams,
options: InvokeOptions,
) -> Result<DocFormatParagraphSetSpacingResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.paragraph.setSpacing", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.paragraph.setSpacing".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_tab_stop(
&self,
params: &DocFormatParagraphSetTabStopBoundParams,
) -> Result<DocFormatParagraphSetTabStopResult> {
self.set_tab_stop_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_tab_stop_with_options(
&self,
params: &DocFormatParagraphSetTabStopBoundParams,
options: InvokeOptions,
) -> Result<DocFormatParagraphSetTabStopResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.format.paragraph.setTabStop", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.format.paragraph.setTabStop".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiHeaderFooters<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiHeaderFooters<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub fn page_numbers(&self) -> DocApiHeaderFootersPageNumbers<'a, I> {
DocApiHeaderFootersPageNumbers::new(self.invoker)
}
pub fn parts(&self) -> DocApiHeaderFootersParts<'a, I> {
DocApiHeaderFootersParts::new(self.invoker)
}
pub fn refs(&self) -> DocApiHeaderFootersRefs<'a, I> {
DocApiHeaderFootersRefs::new(self.invoker)
}
pub async fn get(
&self,
params: &DocHeaderFootersGetBoundParams,
) -> Result<DocHeaderFootersGetResult> {
self.get_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_with_options(
&self,
params: &DocHeaderFootersGetBoundParams,
options: InvokeOptions,
) -> Result<DocHeaderFootersGetResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.headerFooters.get", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.headerFooters.get".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn list(
&self,
params: &DocHeaderFootersListBoundParams,
) -> Result<DocHeaderFootersListResult> {
self.list_with_options(params, InvokeOptions::default())
.await
}
pub async fn list_with_options(
&self,
params: &DocHeaderFootersListBoundParams,
options: InvokeOptions,
) -> Result<DocHeaderFootersListResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.headerFooters.list", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.headerFooters.list".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn resolve(
&self,
params: &DocHeaderFootersResolveBoundParams,
) -> Result<DocHeaderFootersResolveResult> {
self.resolve_with_options(params, InvokeOptions::default())
.await
}
pub async fn resolve_with_options(
&self,
params: &DocHeaderFootersResolveBoundParams,
options: InvokeOptions,
) -> Result<DocHeaderFootersResolveResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.headerFooters.resolve", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.headerFooters.resolve".to_owned());
error.outcome_unknown = false;
error
})
}
}
pub struct DocApiHeaderFootersPageNumbers<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiHeaderFootersPageNumbers<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn get(
&self,
params: &DocHeaderFootersPageNumbersGetBoundParams,
) -> Result<DocHeaderFootersPageNumbersGetResult> {
self.get_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_with_options(
&self,
params: &DocHeaderFootersPageNumbersGetBoundParams,
options: InvokeOptions,
) -> Result<DocHeaderFootersPageNumbersGetResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.headerFooters.pageNumbers.get", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.headerFooters.pageNumbers.get".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn insert(
&self,
params: &DocHeaderFootersPageNumbersInsertBoundParams,
) -> Result<DocHeaderFootersPageNumbersInsertResult> {
self.insert_with_options(params, InvokeOptions::default())
.await
}
pub async fn insert_with_options(
&self,
params: &DocHeaderFootersPageNumbersInsertBoundParams,
options: InvokeOptions,
) -> Result<DocHeaderFootersPageNumbersInsertResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.headerFooters.pageNumbers.insert", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.headerFooters.pageNumbers.insert".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn remove(
&self,
params: &DocHeaderFootersPageNumbersRemoveBoundParams,
) -> Result<DocHeaderFootersPageNumbersRemoveResult> {
self.remove_with_options(params, InvokeOptions::default())
.await
}
pub async fn remove_with_options(
&self,
params: &DocHeaderFootersPageNumbersRemoveBoundParams,
options: InvokeOptions,
) -> Result<DocHeaderFootersPageNumbersRemoveResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.headerFooters.pageNumbers.remove", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.headerFooters.pageNumbers.remove".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set(
&self,
params: &DocHeaderFootersPageNumbersSetBoundParams,
) -> Result<DocHeaderFootersPageNumbersSetResult> {
self.set_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_with_options(
&self,
params: &DocHeaderFootersPageNumbersSetBoundParams,
options: InvokeOptions,
) -> Result<DocHeaderFootersPageNumbersSetResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.headerFooters.pageNumbers.set", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.headerFooters.pageNumbers.set".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiHeaderFootersParts<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiHeaderFootersParts<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn create(
&self,
params: &DocHeaderFootersPartsCreateBoundParams,
) -> Result<DocHeaderFootersPartsCreateResult> {
self.create_with_options(params, InvokeOptions::default())
.await
}
pub async fn create_with_options(
&self,
params: &DocHeaderFootersPartsCreateBoundParams,
options: InvokeOptions,
) -> Result<DocHeaderFootersPartsCreateResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.headerFooters.parts.create", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.headerFooters.parts.create".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn delete(
&self,
params: &DocHeaderFootersPartsDeleteBoundParams,
) -> Result<DocHeaderFootersPartsDeleteResult> {
self.delete_with_options(params, InvokeOptions::default())
.await
}
pub async fn delete_with_options(
&self,
params: &DocHeaderFootersPartsDeleteBoundParams,
options: InvokeOptions,
) -> Result<DocHeaderFootersPartsDeleteResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.headerFooters.parts.delete", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.headerFooters.parts.delete".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn list(
&self,
params: &DocHeaderFootersPartsListBoundParams,
) -> Result<DocHeaderFootersPartsListResult> {
self.list_with_options(params, InvokeOptions::default())
.await
}
pub async fn list_with_options(
&self,
params: &DocHeaderFootersPartsListBoundParams,
options: InvokeOptions,
) -> Result<DocHeaderFootersPartsListResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.headerFooters.parts.list", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.headerFooters.parts.list".to_owned());
error.outcome_unknown = false;
error
})
}
}
pub struct DocApiHeaderFootersRefs<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiHeaderFootersRefs<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn clear(
&self,
params: &DocHeaderFootersRefsClearBoundParams,
) -> Result<DocHeaderFootersRefsClearResult> {
self.clear_with_options(params, InvokeOptions::default())
.await
}
pub async fn clear_with_options(
&self,
params: &DocHeaderFootersRefsClearBoundParams,
options: InvokeOptions,
) -> Result<DocHeaderFootersRefsClearResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.headerFooters.refs.clear", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.headerFooters.refs.clear".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set(
&self,
params: &DocHeaderFootersRefsSetBoundParams,
) -> Result<DocHeaderFootersRefsSetResult> {
self.set_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_with_options(
&self,
params: &DocHeaderFootersRefsSetBoundParams,
options: InvokeOptions,
) -> Result<DocHeaderFootersRefsSetResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.headerFooters.refs.set", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.headerFooters.refs.set".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_linked_to_previous(
&self,
params: &DocHeaderFootersRefsSetLinkedToPreviousBoundParams,
) -> Result<DocHeaderFootersRefsSetLinkedToPreviousResult> {
self.set_linked_to_previous_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_linked_to_previous_with_options(
&self,
params: &DocHeaderFootersRefsSetLinkedToPreviousBoundParams,
options: InvokeOptions,
) -> Result<DocHeaderFootersRefsSetLinkedToPreviousResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke(
"doc.headerFooters.refs.setLinkedToPrevious",
params,
options,
)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.headerFooters.refs.setLinkedToPrevious".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiHistory<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiHistory<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn get(&self, params: &DocHistoryGetBoundParams) -> Result<DocHistoryGetResult> {
self.get_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_with_options(
&self,
params: &DocHistoryGetBoundParams,
options: InvokeOptions,
) -> Result<DocHistoryGetResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.history.get", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.history.get".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn redo(&self, params: &DocHistoryRedoBoundParams) -> Result<DocHistoryRedoResult> {
self.redo_with_options(params, InvokeOptions::default())
.await
}
pub async fn redo_with_options(
&self,
params: &DocHistoryRedoBoundParams,
options: InvokeOptions,
) -> Result<DocHistoryRedoResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.history.redo", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.history.redo".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn undo(&self, params: &DocHistoryUndoBoundParams) -> Result<DocHistoryUndoResult> {
self.undo_with_options(params, InvokeOptions::default())
.await
}
pub async fn undo_with_options(
&self,
params: &DocHistoryUndoBoundParams,
options: InvokeOptions,
) -> Result<DocHistoryUndoResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.history.undo", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.history.undo".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiHyperlinks<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiHyperlinks<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn get(
&self,
params: &DocHyperlinksGetBoundParams,
) -> Result<DocHyperlinksGetResult> {
self.get_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_with_options(
&self,
params: &DocHyperlinksGetBoundParams,
options: InvokeOptions,
) -> Result<DocHyperlinksGetResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.hyperlinks.get", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.hyperlinks.get".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn insert(
&self,
params: &DocHyperlinksInsertBoundParams,
) -> Result<DocHyperlinksInsertResult> {
self.insert_with_options(params, InvokeOptions::default())
.await
}
pub async fn insert_with_options(
&self,
params: &DocHyperlinksInsertBoundParams,
options: InvokeOptions,
) -> Result<DocHyperlinksInsertResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.hyperlinks.insert", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.hyperlinks.insert".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn list(
&self,
params: &DocHyperlinksListBoundParams,
) -> Result<DocHyperlinksListResult> {
self.list_with_options(params, InvokeOptions::default())
.await
}
pub async fn list_with_options(
&self,
params: &DocHyperlinksListBoundParams,
options: InvokeOptions,
) -> Result<DocHyperlinksListResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.hyperlinks.list", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.hyperlinks.list".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn patch(
&self,
params: &DocHyperlinksPatchBoundParams,
) -> Result<DocHyperlinksPatchResult> {
self.patch_with_options(params, InvokeOptions::default())
.await
}
pub async fn patch_with_options(
&self,
params: &DocHyperlinksPatchBoundParams,
options: InvokeOptions,
) -> Result<DocHyperlinksPatchResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.hyperlinks.patch", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.hyperlinks.patch".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn remove(
&self,
params: &DocHyperlinksRemoveBoundParams,
) -> Result<DocHyperlinksRemoveResult> {
self.remove_with_options(params, InvokeOptions::default())
.await
}
pub async fn remove_with_options(
&self,
params: &DocHyperlinksRemoveBoundParams,
options: InvokeOptions,
) -> Result<DocHyperlinksRemoveResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.hyperlinks.remove", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.hyperlinks.remove".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn wrap(
&self,
params: &DocHyperlinksWrapBoundParams,
) -> Result<DocHyperlinksWrapResult> {
self.wrap_with_options(params, InvokeOptions::default())
.await
}
pub async fn wrap_with_options(
&self,
params: &DocHyperlinksWrapBoundParams,
options: InvokeOptions,
) -> Result<DocHyperlinksWrapResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.hyperlinks.wrap", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.hyperlinks.wrap".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiImages<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiImages<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn convert_to_floating(
&self,
params: &DocImagesConvertToFloatingBoundParams,
) -> Result<DocImagesConvertToFloatingResult> {
self.convert_to_floating_with_options(params, InvokeOptions::default())
.await
}
pub async fn convert_to_floating_with_options(
&self,
params: &DocImagesConvertToFloatingBoundParams,
options: InvokeOptions,
) -> Result<DocImagesConvertToFloatingResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.images.convertToFloating", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.images.convertToFloating".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn convert_to_inline(
&self,
params: &DocImagesConvertToInlineBoundParams,
) -> Result<DocImagesConvertToInlineResult> {
self.convert_to_inline_with_options(params, InvokeOptions::default())
.await
}
pub async fn convert_to_inline_with_options(
&self,
params: &DocImagesConvertToInlineBoundParams,
options: InvokeOptions,
) -> Result<DocImagesConvertToInlineResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.images.convertToInline", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.images.convertToInline".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn crop(&self, params: &DocImagesCropBoundParams) -> Result<DocImagesCropResult> {
self.crop_with_options(params, InvokeOptions::default())
.await
}
pub async fn crop_with_options(
&self,
params: &DocImagesCropBoundParams,
options: InvokeOptions,
) -> Result<DocImagesCropResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.images.crop", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.images.crop".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn delete(
&self,
params: &DocImagesDeleteBoundParams,
) -> Result<DocImagesDeleteResult> {
self.delete_with_options(params, InvokeOptions::default())
.await
}
pub async fn delete_with_options(
&self,
params: &DocImagesDeleteBoundParams,
options: InvokeOptions,
) -> Result<DocImagesDeleteResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.images.delete", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.images.delete".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn flip(&self, params: &DocImagesFlipBoundParams) -> Result<DocImagesFlipResult> {
self.flip_with_options(params, InvokeOptions::default())
.await
}
pub async fn flip_with_options(
&self,
params: &DocImagesFlipBoundParams,
options: InvokeOptions,
) -> Result<DocImagesFlipResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.images.flip", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.images.flip".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn get(&self, params: &DocImagesGetBoundParams) -> Result<DocImagesGetResult> {
self.get_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_with_options(
&self,
params: &DocImagesGetBoundParams,
options: InvokeOptions,
) -> Result<DocImagesGetResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.images.get", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.images.get".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn insert_caption(
&self,
params: &DocImagesInsertCaptionBoundParams,
) -> Result<DocImagesInsertCaptionResult> {
self.insert_caption_with_options(params, InvokeOptions::default())
.await
}
pub async fn insert_caption_with_options(
&self,
params: &DocImagesInsertCaptionBoundParams,
options: InvokeOptions,
) -> Result<DocImagesInsertCaptionResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.images.insertCaption", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.images.insertCaption".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn list(&self, params: &DocImagesListBoundParams) -> Result<DocImagesListResult> {
self.list_with_options(params, InvokeOptions::default())
.await
}
pub async fn list_with_options(
&self,
params: &DocImagesListBoundParams,
options: InvokeOptions,
) -> Result<DocImagesListResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.images.list", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.images.list".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn move_(&self, params: &DocImagesMoveBoundParams) -> Result<DocImagesMoveResult> {
self.move_with_options(params, InvokeOptions::default())
.await
}
pub async fn move_with_options(
&self,
params: &DocImagesMoveBoundParams,
options: InvokeOptions,
) -> Result<DocImagesMoveResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.images.move", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.images.move".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn remove_caption(
&self,
params: &DocImagesRemoveCaptionBoundParams,
) -> Result<DocImagesRemoveCaptionResult> {
self.remove_caption_with_options(params, InvokeOptions::default())
.await
}
pub async fn remove_caption_with_options(
&self,
params: &DocImagesRemoveCaptionBoundParams,
options: InvokeOptions,
) -> Result<DocImagesRemoveCaptionResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.images.removeCaption", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.images.removeCaption".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn replace_source(
&self,
params: &DocImagesReplaceSourceBoundParams,
) -> Result<DocImagesReplaceSourceResult> {
self.replace_source_with_options(params, InvokeOptions::default())
.await
}
pub async fn replace_source_with_options(
&self,
params: &DocImagesReplaceSourceBoundParams,
options: InvokeOptions,
) -> Result<DocImagesReplaceSourceResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.images.replaceSource", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.images.replaceSource".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn reset_crop(
&self,
params: &DocImagesResetCropBoundParams,
) -> Result<DocImagesResetCropResult> {
self.reset_crop_with_options(params, InvokeOptions::default())
.await
}
pub async fn reset_crop_with_options(
&self,
params: &DocImagesResetCropBoundParams,
options: InvokeOptions,
) -> Result<DocImagesResetCropResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.images.resetCrop", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.images.resetCrop".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn rotate(
&self,
params: &DocImagesRotateBoundParams,
) -> Result<DocImagesRotateResult> {
self.rotate_with_options(params, InvokeOptions::default())
.await
}
pub async fn rotate_with_options(
&self,
params: &DocImagesRotateBoundParams,
options: InvokeOptions,
) -> Result<DocImagesRotateResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.images.rotate", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.images.rotate".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn scale(&self, params: &DocImagesScaleBoundParams) -> Result<DocImagesScaleResult> {
self.scale_with_options(params, InvokeOptions::default())
.await
}
pub async fn scale_with_options(
&self,
params: &DocImagesScaleBoundParams,
options: InvokeOptions,
) -> Result<DocImagesScaleResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.images.scale", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.images.scale".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_alt_text(
&self,
params: &DocImagesSetAltTextBoundParams,
) -> Result<DocImagesSetAltTextResult> {
self.set_alt_text_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_alt_text_with_options(
&self,
params: &DocImagesSetAltTextBoundParams,
options: InvokeOptions,
) -> Result<DocImagesSetAltTextResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.images.setAltText", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.images.setAltText".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_anchor_options(
&self,
params: &DocImagesSetAnchorOptionsBoundParams,
) -> Result<DocImagesSetAnchorOptionsResult> {
self.set_anchor_options_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_anchor_options_with_options(
&self,
params: &DocImagesSetAnchorOptionsBoundParams,
options: InvokeOptions,
) -> Result<DocImagesSetAnchorOptionsResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.images.setAnchorOptions", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.images.setAnchorOptions".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_decorative(
&self,
params: &DocImagesSetDecorativeBoundParams,
) -> Result<DocImagesSetDecorativeResult> {
self.set_decorative_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_decorative_with_options(
&self,
params: &DocImagesSetDecorativeBoundParams,
options: InvokeOptions,
) -> Result<DocImagesSetDecorativeResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.images.setDecorative", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.images.setDecorative".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_hyperlink(
&self,
params: &DocImagesSetHyperlinkBoundParams,
) -> Result<DocImagesSetHyperlinkResult> {
self.set_hyperlink_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_hyperlink_with_options(
&self,
params: &DocImagesSetHyperlinkBoundParams,
options: InvokeOptions,
) -> Result<DocImagesSetHyperlinkResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.images.setHyperlink", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.images.setHyperlink".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_lock_aspect_ratio(
&self,
params: &DocImagesSetLockAspectRatioBoundParams,
) -> Result<DocImagesSetLockAspectRatioResult> {
self.set_lock_aspect_ratio_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_lock_aspect_ratio_with_options(
&self,
params: &DocImagesSetLockAspectRatioBoundParams,
options: InvokeOptions,
) -> Result<DocImagesSetLockAspectRatioResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.images.setLockAspectRatio", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.images.setLockAspectRatio".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_name(
&self,
params: &DocImagesSetNameBoundParams,
) -> Result<DocImagesSetNameResult> {
self.set_name_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_name_with_options(
&self,
params: &DocImagesSetNameBoundParams,
options: InvokeOptions,
) -> Result<DocImagesSetNameResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.images.setName", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.images.setName".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_position(
&self,
params: &DocImagesSetPositionBoundParams,
) -> Result<DocImagesSetPositionResult> {
self.set_position_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_position_with_options(
&self,
params: &DocImagesSetPositionBoundParams,
options: InvokeOptions,
) -> Result<DocImagesSetPositionResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.images.setPosition", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.images.setPosition".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_size(
&self,
params: &DocImagesSetSizeBoundParams,
) -> Result<DocImagesSetSizeResult> {
self.set_size_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_size_with_options(
&self,
params: &DocImagesSetSizeBoundParams,
options: InvokeOptions,
) -> Result<DocImagesSetSizeResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.images.setSize", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.images.setSize".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_wrap_distances(
&self,
params: &DocImagesSetWrapDistancesBoundParams,
) -> Result<DocImagesSetWrapDistancesResult> {
self.set_wrap_distances_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_wrap_distances_with_options(
&self,
params: &DocImagesSetWrapDistancesBoundParams,
options: InvokeOptions,
) -> Result<DocImagesSetWrapDistancesResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.images.setWrapDistances", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.images.setWrapDistances".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_wrap_side(
&self,
params: &DocImagesSetWrapSideBoundParams,
) -> Result<DocImagesSetWrapSideResult> {
self.set_wrap_side_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_wrap_side_with_options(
&self,
params: &DocImagesSetWrapSideBoundParams,
options: InvokeOptions,
) -> Result<DocImagesSetWrapSideResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.images.setWrapSide", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.images.setWrapSide".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_wrap_type(
&self,
params: &DocImagesSetWrapTypeBoundParams,
) -> Result<DocImagesSetWrapTypeResult> {
self.set_wrap_type_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_wrap_type_with_options(
&self,
params: &DocImagesSetWrapTypeBoundParams,
options: InvokeOptions,
) -> Result<DocImagesSetWrapTypeResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.images.setWrapType", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.images.setWrapType".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_z_order(
&self,
params: &DocImagesSetZOrderBoundParams,
) -> Result<DocImagesSetZOrderResult> {
self.set_z_order_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_z_order_with_options(
&self,
params: &DocImagesSetZOrderBoundParams,
options: InvokeOptions,
) -> Result<DocImagesSetZOrderResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.images.setZOrder", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.images.setZOrder".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn update_caption(
&self,
params: &DocImagesUpdateCaptionBoundParams,
) -> Result<DocImagesUpdateCaptionResult> {
self.update_caption_with_options(params, InvokeOptions::default())
.await
}
pub async fn update_caption_with_options(
&self,
params: &DocImagesUpdateCaptionBoundParams,
options: InvokeOptions,
) -> Result<DocImagesUpdateCaptionResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.images.updateCaption", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.images.updateCaption".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiIndex<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiIndex<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub fn entries(&self) -> DocApiIndexEntries<'a, I> {
DocApiIndexEntries::new(self.invoker)
}
pub async fn configure(
&self,
params: &DocIndexConfigureBoundParams,
) -> Result<DocIndexConfigureResult> {
self.configure_with_options(params, InvokeOptions::default())
.await
}
pub async fn configure_with_options(
&self,
params: &DocIndexConfigureBoundParams,
options: InvokeOptions,
) -> Result<DocIndexConfigureResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.index.configure", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.index.configure".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn get(&self, params: &DocIndexGetBoundParams) -> Result<DocIndexGetResult> {
self.get_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_with_options(
&self,
params: &DocIndexGetBoundParams,
options: InvokeOptions,
) -> Result<DocIndexGetResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.index.get", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.index.get".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn insert(&self, params: &DocIndexInsertBoundParams) -> Result<DocIndexInsertResult> {
self.insert_with_options(params, InvokeOptions::default())
.await
}
pub async fn insert_with_options(
&self,
params: &DocIndexInsertBoundParams,
options: InvokeOptions,
) -> Result<DocIndexInsertResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.index.insert", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.index.insert".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn list(&self, params: &DocIndexListBoundParams) -> Result<DocIndexListResult> {
self.list_with_options(params, InvokeOptions::default())
.await
}
pub async fn list_with_options(
&self,
params: &DocIndexListBoundParams,
options: InvokeOptions,
) -> Result<DocIndexListResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.index.list", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.index.list".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn rebuild(
&self,
params: &DocIndexRebuildBoundParams,
) -> Result<DocIndexRebuildResult> {
self.rebuild_with_options(params, InvokeOptions::default())
.await
}
pub async fn rebuild_with_options(
&self,
params: &DocIndexRebuildBoundParams,
options: InvokeOptions,
) -> Result<DocIndexRebuildResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.index.rebuild", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.index.rebuild".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn remove(&self, params: &DocIndexRemoveBoundParams) -> Result<DocIndexRemoveResult> {
self.remove_with_options(params, InvokeOptions::default())
.await
}
pub async fn remove_with_options(
&self,
params: &DocIndexRemoveBoundParams,
options: InvokeOptions,
) -> Result<DocIndexRemoveResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.index.remove", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.index.remove".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiIndexEntries<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiIndexEntries<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn get(
&self,
params: &DocIndexEntriesGetBoundParams,
) -> Result<DocIndexEntriesGetResult> {
self.get_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_with_options(
&self,
params: &DocIndexEntriesGetBoundParams,
options: InvokeOptions,
) -> Result<DocIndexEntriesGetResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.index.entries.get", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.index.entries.get".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn insert(
&self,
params: &DocIndexEntriesInsertBoundParams,
) -> Result<DocIndexEntriesInsertResult> {
self.insert_with_options(params, InvokeOptions::default())
.await
}
pub async fn insert_with_options(
&self,
params: &DocIndexEntriesInsertBoundParams,
options: InvokeOptions,
) -> Result<DocIndexEntriesInsertResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.index.entries.insert", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.index.entries.insert".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn list(
&self,
params: &DocIndexEntriesListBoundParams,
) -> Result<DocIndexEntriesListResult> {
self.list_with_options(params, InvokeOptions::default())
.await
}
pub async fn list_with_options(
&self,
params: &DocIndexEntriesListBoundParams,
options: InvokeOptions,
) -> Result<DocIndexEntriesListResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.index.entries.list", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.index.entries.list".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn remove(
&self,
params: &DocIndexEntriesRemoveBoundParams,
) -> Result<DocIndexEntriesRemoveResult> {
self.remove_with_options(params, InvokeOptions::default())
.await
}
pub async fn remove_with_options(
&self,
params: &DocIndexEntriesRemoveBoundParams,
options: InvokeOptions,
) -> Result<DocIndexEntriesRemoveResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.index.entries.remove", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.index.entries.remove".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn update(
&self,
params: &DocIndexEntriesUpdateBoundParams,
) -> Result<DocIndexEntriesUpdateResult> {
self.update_with_options(params, InvokeOptions::default())
.await
}
pub async fn update_with_options(
&self,
params: &DocIndexEntriesUpdateBoundParams,
options: InvokeOptions,
) -> Result<DocIndexEntriesUpdateResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.index.entries.update", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.index.entries.update".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiLists<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiLists<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn apply(&self, params: &DocListsApplyBoundParams) -> Result<DocListsApplyResult> {
self.apply_with_options(params, InvokeOptions::default())
.await
}
pub async fn apply_with_options(
&self,
params: &DocListsApplyBoundParams,
options: InvokeOptions,
) -> Result<DocListsApplyResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.apply", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.apply".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn apply_preset(
&self,
params: &DocListsApplyPresetBoundParams,
) -> Result<DocListsApplyPresetResult> {
self.apply_preset_with_options(params, InvokeOptions::default())
.await
}
pub async fn apply_preset_with_options(
&self,
params: &DocListsApplyPresetBoundParams,
options: InvokeOptions,
) -> Result<DocListsApplyPresetResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.applyPreset", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.applyPreset".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn apply_style(
&self,
params: &DocListsApplyStyleBoundParams,
) -> Result<DocListsApplyStyleResult> {
self.apply_style_with_options(params, InvokeOptions::default())
.await
}
pub async fn apply_style_with_options(
&self,
params: &DocListsApplyStyleBoundParams,
options: InvokeOptions,
) -> Result<DocListsApplyStyleResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.applyStyle", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.applyStyle".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn apply_template(
&self,
params: &DocListsApplyTemplateBoundParams,
) -> Result<DocListsApplyTemplateResult> {
self.apply_template_with_options(params, InvokeOptions::default())
.await
}
pub async fn apply_template_with_options(
&self,
params: &DocListsApplyTemplateBoundParams,
options: InvokeOptions,
) -> Result<DocListsApplyTemplateResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.applyTemplate", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.applyTemplate".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn attach(&self, params: &DocListsAttachBoundParams) -> Result<DocListsAttachResult> {
self.attach_with_options(params, InvokeOptions::default())
.await
}
pub async fn attach_with_options(
&self,
params: &DocListsAttachBoundParams,
options: InvokeOptions,
) -> Result<DocListsAttachResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.attach", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.attach".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn can_continue_previous(
&self,
params: &DocListsCanContinuePreviousBoundParams,
) -> Result<DocListsCanContinuePreviousResult> {
self.can_continue_previous_with_options(params, InvokeOptions::default())
.await
}
pub async fn can_continue_previous_with_options(
&self,
params: &DocListsCanContinuePreviousBoundParams,
options: InvokeOptions,
) -> Result<DocListsCanContinuePreviousResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.canContinuePrevious", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.canContinuePrevious".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn can_join(
&self,
params: &DocListsCanJoinBoundParams,
) -> Result<DocListsCanJoinResult> {
self.can_join_with_options(params, InvokeOptions::default())
.await
}
pub async fn can_join_with_options(
&self,
params: &DocListsCanJoinBoundParams,
options: InvokeOptions,
) -> Result<DocListsCanJoinResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.canJoin", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.canJoin".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn capture_template(
&self,
params: &DocListsCaptureTemplateBoundParams,
) -> Result<DocListsCaptureTemplateResult> {
self.capture_template_with_options(params, InvokeOptions::default())
.await
}
pub async fn capture_template_with_options(
&self,
params: &DocListsCaptureTemplateBoundParams,
options: InvokeOptions,
) -> Result<DocListsCaptureTemplateResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.captureTemplate", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.captureTemplate".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn clear_level_overrides(
&self,
params: &DocListsClearLevelOverridesBoundParams,
) -> Result<DocListsClearLevelOverridesResult> {
self.clear_level_overrides_with_options(params, InvokeOptions::default())
.await
}
pub async fn clear_level_overrides_with_options(
&self,
params: &DocListsClearLevelOverridesBoundParams,
options: InvokeOptions,
) -> Result<DocListsClearLevelOverridesResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.clearLevelOverrides", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.clearLevelOverrides".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn continue_(
&self,
params: &DocListsContinueBoundParams,
) -> Result<DocListsContinueResult> {
self.continue_with_options(params, InvokeOptions::default())
.await
}
pub async fn continue_with_options(
&self,
params: &DocListsContinueBoundParams,
options: InvokeOptions,
) -> Result<DocListsContinueResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.continue", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.continue".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn continue_previous(
&self,
params: &DocListsContinuePreviousBoundParams,
) -> Result<DocListsContinuePreviousResult> {
self.continue_previous_with_options(params, InvokeOptions::default())
.await
}
pub async fn continue_previous_with_options(
&self,
params: &DocListsContinuePreviousBoundParams,
options: InvokeOptions,
) -> Result<DocListsContinuePreviousResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.continuePrevious", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.continuePrevious".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn convert_to_text(
&self,
params: &DocListsConvertToTextBoundParams,
) -> Result<DocListsConvertToTextResult> {
self.convert_to_text_with_options(params, InvokeOptions::default())
.await
}
pub async fn convert_to_text_with_options(
&self,
params: &DocListsConvertToTextBoundParams,
options: InvokeOptions,
) -> Result<DocListsConvertToTextResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.convertToText", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.convertToText".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn create(&self, params: &DocListsCreateBoundParams) -> Result<DocListsCreateResult> {
self.create_with_options(params, InvokeOptions::default())
.await
}
pub async fn create_with_options(
&self,
params: &DocListsCreateBoundParams,
options: InvokeOptions,
) -> Result<DocListsCreateResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.create", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.create".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn delete(&self, params: &DocListsDeleteBoundParams) -> Result<DocListsDeleteResult> {
self.delete_with_options(params, InvokeOptions::default())
.await
}
pub async fn delete_with_options(
&self,
params: &DocListsDeleteBoundParams,
options: InvokeOptions,
) -> Result<DocListsDeleteResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.delete", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.delete".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn detach(&self, params: &DocListsDetachBoundParams) -> Result<DocListsDetachResult> {
self.detach_with_options(params, InvokeOptions::default())
.await
}
pub async fn detach_with_options(
&self,
params: &DocListsDetachBoundParams,
options: InvokeOptions,
) -> Result<DocListsDetachResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.detach", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.detach".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn get(&self, params: &DocListsGetBoundParams) -> Result<DocListsGetResult> {
self.get_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_with_options(
&self,
params: &DocListsGetBoundParams,
options: InvokeOptions,
) -> Result<DocListsGetResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.get", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.get".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn get_state(
&self,
params: &DocListsGetStateBoundParams,
) -> Result<DocListsGetStateResult> {
self.get_state_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_state_with_options(
&self,
params: &DocListsGetStateBoundParams,
options: InvokeOptions,
) -> Result<DocListsGetStateResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.getState", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.getState".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn get_style(
&self,
params: &DocListsGetStyleBoundParams,
) -> Result<DocListsGetStyleResult> {
self.get_style_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_style_with_options(
&self,
params: &DocListsGetStyleBoundParams,
options: InvokeOptions,
) -> Result<DocListsGetStyleResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.getStyle", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.getStyle".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn indent(&self, params: &DocListsIndentBoundParams) -> Result<DocListsIndentResult> {
self.indent_with_options(params, InvokeOptions::default())
.await
}
pub async fn indent_with_options(
&self,
params: &DocListsIndentBoundParams,
options: InvokeOptions,
) -> Result<DocListsIndentResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.indent", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.indent".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn insert(&self, params: &DocListsInsertBoundParams) -> Result<DocListsInsertResult> {
self.insert_with_options(params, InvokeOptions::default())
.await
}
pub async fn insert_with_options(
&self,
params: &DocListsInsertBoundParams,
options: InvokeOptions,
) -> Result<DocListsInsertResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.insert", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.insert".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn join(&self, params: &DocListsJoinBoundParams) -> Result<DocListsJoinResult> {
self.join_with_options(params, InvokeOptions::default())
.await
}
pub async fn join_with_options(
&self,
params: &DocListsJoinBoundParams,
options: InvokeOptions,
) -> Result<DocListsJoinResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.join", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.join".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn list(&self, params: &DocListsListBoundParams) -> Result<DocListsListResult> {
self.list_with_options(params, InvokeOptions::default())
.await
}
pub async fn list_with_options(
&self,
params: &DocListsListBoundParams,
options: InvokeOptions,
) -> Result<DocListsListResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.list", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.list".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn merge(&self, params: &DocListsMergeBoundParams) -> Result<DocListsMergeResult> {
self.merge_with_options(params, InvokeOptions::default())
.await
}
pub async fn merge_with_options(
&self,
params: &DocListsMergeBoundParams,
options: InvokeOptions,
) -> Result<DocListsMergeResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.merge", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.merge".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn outdent(
&self,
params: &DocListsOutdentBoundParams,
) -> Result<DocListsOutdentResult> {
self.outdent_with_options(params, InvokeOptions::default())
.await
}
pub async fn outdent_with_options(
&self,
params: &DocListsOutdentBoundParams,
options: InvokeOptions,
) -> Result<DocListsOutdentResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.outdent", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.outdent".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn remove(&self, params: &DocListsRemoveBoundParams) -> Result<DocListsRemoveResult> {
self.remove_with_options(params, InvokeOptions::default())
.await
}
pub async fn remove_with_options(
&self,
params: &DocListsRemoveBoundParams,
options: InvokeOptions,
) -> Result<DocListsRemoveResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.remove", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.remove".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn restart(
&self,
params: &DocListsRestartBoundParams,
) -> Result<DocListsRestartResult> {
self.restart_with_options(params, InvokeOptions::default())
.await
}
pub async fn restart_with_options(
&self,
params: &DocListsRestartBoundParams,
options: InvokeOptions,
) -> Result<DocListsRestartResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.restart", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.restart".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn restart_at(
&self,
params: &DocListsRestartAtBoundParams,
) -> Result<DocListsRestartAtResult> {
self.restart_at_with_options(params, InvokeOptions::default())
.await
}
pub async fn restart_at_with_options(
&self,
params: &DocListsRestartAtBoundParams,
options: InvokeOptions,
) -> Result<DocListsRestartAtResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.restartAt", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.restartAt".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn separate(
&self,
params: &DocListsSeparateBoundParams,
) -> Result<DocListsSeparateResult> {
self.separate_with_options(params, InvokeOptions::default())
.await
}
pub async fn separate_with_options(
&self,
params: &DocListsSeparateBoundParams,
options: InvokeOptions,
) -> Result<DocListsSeparateResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.separate", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.separate".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_level(
&self,
params: &DocListsSetLevelBoundParams,
) -> Result<DocListsSetLevelResult> {
self.set_level_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_level_with_options(
&self,
params: &DocListsSetLevelBoundParams,
options: InvokeOptions,
) -> Result<DocListsSetLevelResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.setLevel", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.setLevel".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_level_alignment(
&self,
params: &DocListsSetLevelAlignmentBoundParams,
) -> Result<DocListsSetLevelAlignmentResult> {
self.set_level_alignment_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_level_alignment_with_options(
&self,
params: &DocListsSetLevelAlignmentBoundParams,
options: InvokeOptions,
) -> Result<DocListsSetLevelAlignmentResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.setLevelAlignment", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.setLevelAlignment".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_level_bullet(
&self,
params: &DocListsSetLevelBulletBoundParams,
) -> Result<DocListsSetLevelBulletResult> {
self.set_level_bullet_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_level_bullet_with_options(
&self,
params: &DocListsSetLevelBulletBoundParams,
options: InvokeOptions,
) -> Result<DocListsSetLevelBulletResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.setLevelBullet", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.setLevelBullet".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_level_indents(
&self,
params: &DocListsSetLevelIndentsBoundParams,
) -> Result<DocListsSetLevelIndentsResult> {
self.set_level_indents_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_level_indents_with_options(
&self,
params: &DocListsSetLevelIndentsBoundParams,
options: InvokeOptions,
) -> Result<DocListsSetLevelIndentsResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.setLevelIndents", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.setLevelIndents".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_level_layout(
&self,
params: &DocListsSetLevelLayoutBoundParams,
) -> Result<DocListsSetLevelLayoutResult> {
self.set_level_layout_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_level_layout_with_options(
&self,
params: &DocListsSetLevelLayoutBoundParams,
options: InvokeOptions,
) -> Result<DocListsSetLevelLayoutResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.setLevelLayout", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.setLevelLayout".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_level_marker_font(
&self,
params: &DocListsSetLevelMarkerFontBoundParams,
) -> Result<DocListsSetLevelMarkerFontResult> {
self.set_level_marker_font_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_level_marker_font_with_options(
&self,
params: &DocListsSetLevelMarkerFontBoundParams,
options: InvokeOptions,
) -> Result<DocListsSetLevelMarkerFontResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.setLevelMarkerFont", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.setLevelMarkerFont".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_level_numbering(
&self,
params: &DocListsSetLevelNumberingBoundParams,
) -> Result<DocListsSetLevelNumberingResult> {
self.set_level_numbering_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_level_numbering_with_options(
&self,
params: &DocListsSetLevelNumberingBoundParams,
options: InvokeOptions,
) -> Result<DocListsSetLevelNumberingResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.setLevelNumbering", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.setLevelNumbering".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_level_number_style(
&self,
params: &DocListsSetLevelNumberStyleBoundParams,
) -> Result<DocListsSetLevelNumberStyleResult> {
self.set_level_number_style_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_level_number_style_with_options(
&self,
params: &DocListsSetLevelNumberStyleBoundParams,
options: InvokeOptions,
) -> Result<DocListsSetLevelNumberStyleResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.setLevelNumberStyle", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.setLevelNumberStyle".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_level_picture_bullet(
&self,
params: &DocListsSetLevelPictureBulletBoundParams,
) -> Result<DocListsSetLevelPictureBulletResult> {
self.set_level_picture_bullet_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_level_picture_bullet_with_options(
&self,
params: &DocListsSetLevelPictureBulletBoundParams,
options: InvokeOptions,
) -> Result<DocListsSetLevelPictureBulletResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.setLevelPictureBullet", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.setLevelPictureBullet".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_level_restart(
&self,
params: &DocListsSetLevelRestartBoundParams,
) -> Result<DocListsSetLevelRestartResult> {
self.set_level_restart_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_level_restart_with_options(
&self,
params: &DocListsSetLevelRestartBoundParams,
options: InvokeOptions,
) -> Result<DocListsSetLevelRestartResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.setLevelRestart", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.setLevelRestart".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_level_start(
&self,
params: &DocListsSetLevelStartBoundParams,
) -> Result<DocListsSetLevelStartResult> {
self.set_level_start_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_level_start_with_options(
&self,
params: &DocListsSetLevelStartBoundParams,
options: InvokeOptions,
) -> Result<DocListsSetLevelStartResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.setLevelStart", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.setLevelStart".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_level_text(
&self,
params: &DocListsSetLevelTextBoundParams,
) -> Result<DocListsSetLevelTextResult> {
self.set_level_text_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_level_text_with_options(
&self,
params: &DocListsSetLevelTextBoundParams,
options: InvokeOptions,
) -> Result<DocListsSetLevelTextResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.setLevelText", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.setLevelText".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_level_trailing_character(
&self,
params: &DocListsSetLevelTrailingCharacterBoundParams,
) -> Result<DocListsSetLevelTrailingCharacterResult> {
self.set_level_trailing_character_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_level_trailing_character_with_options(
&self,
params: &DocListsSetLevelTrailingCharacterBoundParams,
options: InvokeOptions,
) -> Result<DocListsSetLevelTrailingCharacterResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.setLevelTrailingCharacter", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.setLevelTrailingCharacter".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_type(
&self,
params: &DocListsSetTypeBoundParams,
) -> Result<DocListsSetTypeResult> {
self.set_type_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_type_with_options(
&self,
params: &DocListsSetTypeBoundParams,
options: InvokeOptions,
) -> Result<DocListsSetTypeResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.setType", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.setType".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_value(
&self,
params: &DocListsSetValueBoundParams,
) -> Result<DocListsSetValueResult> {
self.set_value_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_value_with_options(
&self,
params: &DocListsSetValueBoundParams,
options: InvokeOptions,
) -> Result<DocListsSetValueResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.setValue", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.setValue".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn split(&self, params: &DocListsSplitBoundParams) -> Result<DocListsSplitResult> {
self.split_with_options(params, InvokeOptions::default())
.await
}
pub async fn split_with_options(
&self,
params: &DocListsSplitBoundParams,
options: InvokeOptions,
) -> Result<DocListsSplitResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.lists.split", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.lists.split".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiMetadata<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiMetadata<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn attach(
&self,
params: &DocMetadataAttachBoundParams,
) -> Result<DocMetadataAttachResult> {
self.attach_with_options(params, InvokeOptions::default())
.await
}
pub async fn attach_with_options(
&self,
params: &DocMetadataAttachBoundParams,
options: InvokeOptions,
) -> Result<DocMetadataAttachResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.metadata.attach", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.metadata.attach".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn get(&self, params: &DocMetadataGetBoundParams) -> Result<DocMetadataGetResult> {
self.get_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_with_options(
&self,
params: &DocMetadataGetBoundParams,
options: InvokeOptions,
) -> Result<DocMetadataGetResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.metadata.get", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.metadata.get".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn list(&self, params: &DocMetadataListBoundParams) -> Result<DocMetadataListResult> {
self.list_with_options(params, InvokeOptions::default())
.await
}
pub async fn list_with_options(
&self,
params: &DocMetadataListBoundParams,
options: InvokeOptions,
) -> Result<DocMetadataListResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.metadata.list", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.metadata.list".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn remove(
&self,
params: &DocMetadataRemoveBoundParams,
) -> Result<DocMetadataRemoveResult> {
self.remove_with_options(params, InvokeOptions::default())
.await
}
pub async fn remove_with_options(
&self,
params: &DocMetadataRemoveBoundParams,
options: InvokeOptions,
) -> Result<DocMetadataRemoveResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.metadata.remove", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.metadata.remove".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn resolve(
&self,
params: &DocMetadataResolveBoundParams,
) -> Result<DocMetadataResolveResult> {
self.resolve_with_options(params, InvokeOptions::default())
.await
}
pub async fn resolve_with_options(
&self,
params: &DocMetadataResolveBoundParams,
options: InvokeOptions,
) -> Result<DocMetadataResolveResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.metadata.resolve", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.metadata.resolve".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn update(
&self,
params: &DocMetadataUpdateBoundParams,
) -> Result<DocMetadataUpdateResult> {
self.update_with_options(params, InvokeOptions::default())
.await
}
pub async fn update_with_options(
&self,
params: &DocMetadataUpdateBoundParams,
options: InvokeOptions,
) -> Result<DocMetadataUpdateResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.metadata.update", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.metadata.update".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiMutations<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiMutations<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn apply(
&self,
params: &DocMutationsApplyBoundParams,
) -> Result<DocMutationsApplyResult> {
self.apply_with_options(params, InvokeOptions::default())
.await
}
pub async fn apply_with_options(
&self,
params: &DocMutationsApplyBoundParams,
options: InvokeOptions,
) -> Result<DocMutationsApplyResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.mutations.apply", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.mutations.apply".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn preview(
&self,
params: &DocMutationsPreviewBoundParams,
) -> Result<DocMutationsPreviewResult> {
self.preview_with_options(params, InvokeOptions::default())
.await
}
pub async fn preview_with_options(
&self,
params: &DocMutationsPreviewBoundParams,
options: InvokeOptions,
) -> Result<DocMutationsPreviewResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.mutations.preview", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.mutations.preview".to_owned());
error.outcome_unknown = false;
error
})
}
}
pub struct DocApiPermissionRanges<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiPermissionRanges<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn create(
&self,
params: &DocPermissionRangesCreateBoundParams,
) -> Result<DocPermissionRangesCreateResult> {
self.create_with_options(params, InvokeOptions::default())
.await
}
pub async fn create_with_options(
&self,
params: &DocPermissionRangesCreateBoundParams,
options: InvokeOptions,
) -> Result<DocPermissionRangesCreateResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.permissionRanges.create", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.permissionRanges.create".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn get(
&self,
params: &DocPermissionRangesGetBoundParams,
) -> Result<DocPermissionRangesGetResult> {
self.get_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_with_options(
&self,
params: &DocPermissionRangesGetBoundParams,
options: InvokeOptions,
) -> Result<DocPermissionRangesGetResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.permissionRanges.get", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.permissionRanges.get".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn list(
&self,
params: &DocPermissionRangesListBoundParams,
) -> Result<DocPermissionRangesListResult> {
self.list_with_options(params, InvokeOptions::default())
.await
}
pub async fn list_with_options(
&self,
params: &DocPermissionRangesListBoundParams,
options: InvokeOptions,
) -> Result<DocPermissionRangesListResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.permissionRanges.list", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.permissionRanges.list".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn remove(
&self,
params: &DocPermissionRangesRemoveBoundParams,
) -> Result<DocPermissionRangesRemoveResult> {
self.remove_with_options(params, InvokeOptions::default())
.await
}
pub async fn remove_with_options(
&self,
params: &DocPermissionRangesRemoveBoundParams,
options: InvokeOptions,
) -> Result<DocPermissionRangesRemoveResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.permissionRanges.remove", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.permissionRanges.remove".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn update_principal(
&self,
params: &DocPermissionRangesUpdatePrincipalBoundParams,
) -> Result<DocPermissionRangesUpdatePrincipalResult> {
self.update_principal_with_options(params, InvokeOptions::default())
.await
}
pub async fn update_principal_with_options(
&self,
params: &DocPermissionRangesUpdatePrincipalBoundParams,
options: InvokeOptions,
) -> Result<DocPermissionRangesUpdatePrincipalResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.permissionRanges.updatePrincipal", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.permissionRanges.updatePrincipal".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiPlan<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiPlan<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn execute(
&self,
params: &DocPlanExecuteBoundParams,
) -> Result<DocPlanExecuteResult> {
self.execute_with_options(params, InvokeOptions::default())
.await
}
pub async fn execute_with_options(
&self,
params: &DocPlanExecuteBoundParams,
options: InvokeOptions,
) -> Result<DocPlanExecuteResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.plan.execute", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.plan.execute".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiPreset<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiPreset<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn dispatch(
&self,
params: &DocPresetDispatchBoundParams,
) -> Result<DocPresetDispatchResult> {
self.dispatch_with_options(params, InvokeOptions::default())
.await
}
pub async fn dispatch_with_options(
&self,
params: &DocPresetDispatchBoundParams,
options: InvokeOptions,
) -> Result<DocPresetDispatchResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.preset.dispatch", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.preset.dispatch".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn get_catalog(
&self,
params: &DocPresetGetCatalogBoundParams,
) -> Result<DocPresetGetCatalogResult> {
self.get_catalog_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_catalog_with_options(
&self,
params: &DocPresetGetCatalogBoundParams,
options: InvokeOptions,
) -> Result<DocPresetGetCatalogResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.preset.getCatalog", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.preset.getCatalog".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn get_mcp_prompt(
&self,
params: &DocPresetGetMcpPromptBoundParams,
) -> Result<DocPresetGetMcpPromptResult> {
self.get_mcp_prompt_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_mcp_prompt_with_options(
&self,
params: &DocPresetGetMcpPromptBoundParams,
options: InvokeOptions,
) -> Result<DocPresetGetMcpPromptResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.preset.getMcpPrompt", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.preset.getMcpPrompt".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn get_system_prompt(
&self,
params: &DocPresetGetSystemPromptBoundParams,
) -> Result<DocPresetGetSystemPromptResult> {
self.get_system_prompt_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_system_prompt_with_options(
&self,
params: &DocPresetGetSystemPromptBoundParams,
options: InvokeOptions,
) -> Result<DocPresetGetSystemPromptResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.preset.getSystemPrompt", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.preset.getSystemPrompt".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn get_tools(
&self,
params: &DocPresetGetToolsBoundParams,
) -> Result<DocPresetGetToolsResult> {
self.get_tools_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_tools_with_options(
&self,
params: &DocPresetGetToolsBoundParams,
options: InvokeOptions,
) -> Result<DocPresetGetToolsResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.preset.getTools", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.preset.getTools".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn list(&self, params: &DocPresetListBoundParams) -> Result<DocPresetListResult> {
self.list_with_options(params, InvokeOptions::default())
.await
}
pub async fn list_with_options(
&self,
params: &DocPresetListBoundParams,
options: InvokeOptions,
) -> Result<DocPresetListResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.preset.list", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.preset.list".to_owned());
error.outcome_unknown = false;
error
})
}
}
pub struct DocApiProtection<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiProtection<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn clear_editing_restriction(
&self,
params: &DocProtectionClearEditingRestrictionBoundParams,
) -> Result<DocProtectionClearEditingRestrictionResult> {
self.clear_editing_restriction_with_options(params, InvokeOptions::default())
.await
}
pub async fn clear_editing_restriction_with_options(
&self,
params: &DocProtectionClearEditingRestrictionBoundParams,
options: InvokeOptions,
) -> Result<DocProtectionClearEditingRestrictionResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.protection.clearEditingRestriction", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.protection.clearEditingRestriction".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn get(
&self,
params: &DocProtectionGetBoundParams,
) -> Result<DocProtectionGetResult> {
self.get_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_with_options(
&self,
params: &DocProtectionGetBoundParams,
options: InvokeOptions,
) -> Result<DocProtectionGetResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.protection.get", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.protection.get".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn set_editing_restriction(
&self,
params: &DocProtectionSetEditingRestrictionBoundParams,
) -> Result<DocProtectionSetEditingRestrictionResult> {
self.set_editing_restriction_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_editing_restriction_with_options(
&self,
params: &DocProtectionSetEditingRestrictionBoundParams,
options: InvokeOptions,
) -> Result<DocProtectionSetEditingRestrictionResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.protection.setEditingRestriction", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.protection.setEditingRestriction".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiQuery<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiQuery<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn match_(&self, params: &DocQueryMatchBoundParams) -> Result<DocQueryMatchResult> {
self.match_with_options(params, InvokeOptions::default())
.await
}
pub async fn match_with_options(
&self,
params: &DocQueryMatchBoundParams,
options: InvokeOptions,
) -> Result<DocQueryMatchResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.query.match", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.query.match".to_owned());
error.outcome_unknown = false;
error
})
}
}
pub struct DocApiRanges<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiRanges<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn resolve(
&self,
params: &DocRangesResolveBoundParams,
) -> Result<DocRangesResolveResult> {
self.resolve_with_options(params, InvokeOptions::default())
.await
}
pub async fn resolve_with_options(
&self,
params: &DocRangesResolveBoundParams,
options: InvokeOptions,
) -> Result<DocRangesResolveResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.ranges.resolve", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.ranges.resolve".to_owned());
error.outcome_unknown = false;
error
})
}
}
pub struct DocApiSections<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiSections<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn clear_header_footer_ref(
&self,
params: &DocSectionsClearHeaderFooterRefBoundParams,
) -> Result<DocSectionsClearHeaderFooterRefResult> {
self.clear_header_footer_ref_with_options(params, InvokeOptions::default())
.await
}
pub async fn clear_header_footer_ref_with_options(
&self,
params: &DocSectionsClearHeaderFooterRefBoundParams,
options: InvokeOptions,
) -> Result<DocSectionsClearHeaderFooterRefResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.sections.clearHeaderFooterRef", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.sections.clearHeaderFooterRef".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn clear_page_borders(
&self,
params: &DocSectionsClearPageBordersBoundParams,
) -> Result<DocSectionsClearPageBordersResult> {
self.clear_page_borders_with_options(params, InvokeOptions::default())
.await
}
pub async fn clear_page_borders_with_options(
&self,
params: &DocSectionsClearPageBordersBoundParams,
options: InvokeOptions,
) -> Result<DocSectionsClearPageBordersResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.sections.clearPageBorders", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.sections.clearPageBorders".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn get(&self, params: &DocSectionsGetBoundParams) -> Result<DocSectionsGetResult> {
self.get_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_with_options(
&self,
params: &DocSectionsGetBoundParams,
options: InvokeOptions,
) -> Result<DocSectionsGetResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.sections.get", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.sections.get".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn list(&self, params: &DocSectionsListBoundParams) -> Result<DocSectionsListResult> {
self.list_with_options(params, InvokeOptions::default())
.await
}
pub async fn list_with_options(
&self,
params: &DocSectionsListBoundParams,
options: InvokeOptions,
) -> Result<DocSectionsListResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.sections.list", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.sections.list".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn set_break_type(
&self,
params: &DocSectionsSetBreakTypeBoundParams,
) -> Result<DocSectionsSetBreakTypeResult> {
self.set_break_type_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_break_type_with_options(
&self,
params: &DocSectionsSetBreakTypeBoundParams,
options: InvokeOptions,
) -> Result<DocSectionsSetBreakTypeResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.sections.setBreakType", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.sections.setBreakType".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_columns(
&self,
params: &DocSectionsSetColumnsBoundParams,
) -> Result<DocSectionsSetColumnsResult> {
self.set_columns_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_columns_with_options(
&self,
params: &DocSectionsSetColumnsBoundParams,
options: InvokeOptions,
) -> Result<DocSectionsSetColumnsResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.sections.setColumns", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.sections.setColumns".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_header_footer_margins(
&self,
params: &DocSectionsSetHeaderFooterMarginsBoundParams,
) -> Result<DocSectionsSetHeaderFooterMarginsResult> {
self.set_header_footer_margins_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_header_footer_margins_with_options(
&self,
params: &DocSectionsSetHeaderFooterMarginsBoundParams,
options: InvokeOptions,
) -> Result<DocSectionsSetHeaderFooterMarginsResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.sections.setHeaderFooterMargins", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.sections.setHeaderFooterMargins".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_header_footer_ref(
&self,
params: &DocSectionsSetHeaderFooterRefBoundParams,
) -> Result<DocSectionsSetHeaderFooterRefResult> {
self.set_header_footer_ref_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_header_footer_ref_with_options(
&self,
params: &DocSectionsSetHeaderFooterRefBoundParams,
options: InvokeOptions,
) -> Result<DocSectionsSetHeaderFooterRefResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.sections.setHeaderFooterRef", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.sections.setHeaderFooterRef".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_line_numbering(
&self,
params: &DocSectionsSetLineNumberingBoundParams,
) -> Result<DocSectionsSetLineNumberingResult> {
self.set_line_numbering_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_line_numbering_with_options(
&self,
params: &DocSectionsSetLineNumberingBoundParams,
options: InvokeOptions,
) -> Result<DocSectionsSetLineNumberingResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.sections.setLineNumbering", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.sections.setLineNumbering".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_link_to_previous(
&self,
params: &DocSectionsSetLinkToPreviousBoundParams,
) -> Result<DocSectionsSetLinkToPreviousResult> {
self.set_link_to_previous_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_link_to_previous_with_options(
&self,
params: &DocSectionsSetLinkToPreviousBoundParams,
options: InvokeOptions,
) -> Result<DocSectionsSetLinkToPreviousResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.sections.setLinkToPrevious", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.sections.setLinkToPrevious".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_odd_even_headers_footers(
&self,
params: &DocSectionsSetOddEvenHeadersFootersBoundParams,
) -> Result<DocSectionsSetOddEvenHeadersFootersResult> {
self.set_odd_even_headers_footers_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_odd_even_headers_footers_with_options(
&self,
params: &DocSectionsSetOddEvenHeadersFootersBoundParams,
options: InvokeOptions,
) -> Result<DocSectionsSetOddEvenHeadersFootersResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.sections.setOddEvenHeadersFooters", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.sections.setOddEvenHeadersFooters".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_page_borders(
&self,
params: &DocSectionsSetPageBordersBoundParams,
) -> Result<DocSectionsSetPageBordersResult> {
self.set_page_borders_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_page_borders_with_options(
&self,
params: &DocSectionsSetPageBordersBoundParams,
options: InvokeOptions,
) -> Result<DocSectionsSetPageBordersResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.sections.setPageBorders", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.sections.setPageBorders".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_page_margins(
&self,
params: &DocSectionsSetPageMarginsBoundParams,
) -> Result<DocSectionsSetPageMarginsResult> {
self.set_page_margins_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_page_margins_with_options(
&self,
params: &DocSectionsSetPageMarginsBoundParams,
options: InvokeOptions,
) -> Result<DocSectionsSetPageMarginsResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.sections.setPageMargins", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.sections.setPageMargins".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_page_numbering(
&self,
params: &DocSectionsSetPageNumberingBoundParams,
) -> Result<DocSectionsSetPageNumberingResult> {
self.set_page_numbering_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_page_numbering_with_options(
&self,
params: &DocSectionsSetPageNumberingBoundParams,
options: InvokeOptions,
) -> Result<DocSectionsSetPageNumberingResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.sections.setPageNumbering", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.sections.setPageNumbering".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_page_setup(
&self,
params: &DocSectionsSetPageSetupBoundParams,
) -> Result<DocSectionsSetPageSetupResult> {
self.set_page_setup_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_page_setup_with_options(
&self,
params: &DocSectionsSetPageSetupBoundParams,
options: InvokeOptions,
) -> Result<DocSectionsSetPageSetupResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.sections.setPageSetup", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.sections.setPageSetup".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_section_direction(
&self,
params: &DocSectionsSetSectionDirectionBoundParams,
) -> Result<DocSectionsSetSectionDirectionResult> {
self.set_section_direction_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_section_direction_with_options(
&self,
params: &DocSectionsSetSectionDirectionBoundParams,
options: InvokeOptions,
) -> Result<DocSectionsSetSectionDirectionResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.sections.setSectionDirection", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.sections.setSectionDirection".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_title_page(
&self,
params: &DocSectionsSetTitlePageBoundParams,
) -> Result<DocSectionsSetTitlePageResult> {
self.set_title_page_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_title_page_with_options(
&self,
params: &DocSectionsSetTitlePageBoundParams,
options: InvokeOptions,
) -> Result<DocSectionsSetTitlePageResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.sections.setTitlePage", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.sections.setTitlePage".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_vertical_align(
&self,
params: &DocSectionsSetVerticalAlignBoundParams,
) -> Result<DocSectionsSetVerticalAlignResult> {
self.set_vertical_align_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_vertical_align_with_options(
&self,
params: &DocSectionsSetVerticalAlignBoundParams,
options: InvokeOptions,
) -> Result<DocSectionsSetVerticalAlignResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.sections.setVerticalAlign", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.sections.setVerticalAlign".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiSelection<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiSelection<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn current(
&self,
params: &DocSelectionCurrentBoundParams,
) -> Result<DocSelectionCurrentResult> {
self.current_with_options(params, InvokeOptions::default())
.await
}
pub async fn current_with_options(
&self,
params: &DocSelectionCurrentBoundParams,
options: InvokeOptions,
) -> Result<DocSelectionCurrentResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.selection.current", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.selection.current".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn extract_ooxml(
&self,
params: &DocSelectionExtractOoxmlBoundParams,
) -> Result<DocSelectionExtractOoxmlResult> {
self.extract_ooxml_with_options(params, InvokeOptions::default())
.await
}
pub async fn extract_ooxml_with_options(
&self,
params: &DocSelectionExtractOoxmlBoundParams,
options: InvokeOptions,
) -> Result<DocSelectionExtractOoxmlResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.selection.extractOoxml", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.selection.extractOoxml".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn release_snapshot(
&self,
params: &DocSelectionReleaseSnapshotBoundParams,
) -> Result<DocSelectionReleaseSnapshotResult> {
self.release_snapshot_with_options(params, InvokeOptions::default())
.await
}
pub async fn release_snapshot_with_options(
&self,
params: &DocSelectionReleaseSnapshotBoundParams,
options: InvokeOptions,
) -> Result<DocSelectionReleaseSnapshotResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.selection.releaseSnapshot", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.selection.releaseSnapshot".to_owned());
error.outcome_unknown = false;
error
})
}
}
pub struct DocApiStyles<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiStyles<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub fn paragraph(&self) -> DocApiStylesParagraph<'a, I> {
DocApiStylesParagraph::new(self.invoker)
}
pub async fn apply(&self, params: &DocStylesApplyBoundParams) -> Result<DocStylesApplyResult> {
self.apply_with_options(params, InvokeOptions::default())
.await
}
pub async fn apply_with_options(
&self,
params: &DocStylesApplyBoundParams,
options: InvokeOptions,
) -> Result<DocStylesApplyResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.styles.apply", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.styles.apply".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn create(
&self,
params: &DocStylesCreateBoundParams,
) -> Result<DocStylesCreateResult> {
self.create_with_options(params, InvokeOptions::default())
.await
}
pub async fn create_with_options(
&self,
params: &DocStylesCreateBoundParams,
options: InvokeOptions,
) -> Result<DocStylesCreateResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.styles.create", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.styles.create".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn get_catalog(
&self,
params: &DocStylesGetCatalogBoundParams,
) -> Result<DocStylesGetCatalogResult> {
self.get_catalog_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_catalog_with_options(
&self,
params: &DocStylesGetCatalogBoundParams,
options: InvokeOptions,
) -> Result<DocStylesGetCatalogResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.styles.getCatalog", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.styles.getCatalog".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn get_theme(
&self,
params: &DocStylesGetThemeBoundParams,
) -> Result<DocStylesGetThemeResult> {
self.get_theme_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_theme_with_options(
&self,
params: &DocStylesGetThemeBoundParams,
options: InvokeOptions,
) -> Result<DocStylesGetThemeResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.styles.getTheme", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.styles.getTheme".to_owned());
error.outcome_unknown = false;
error
})
}
}
pub struct DocApiStylesParagraph<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiStylesParagraph<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn clear_style(
&self,
params: &DocStylesParagraphClearStyleBoundParams,
) -> Result<DocStylesParagraphClearStyleResult> {
self.clear_style_with_options(params, InvokeOptions::default())
.await
}
pub async fn clear_style_with_options(
&self,
params: &DocStylesParagraphClearStyleBoundParams,
options: InvokeOptions,
) -> Result<DocStylesParagraphClearStyleResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.styles.paragraph.clearStyle", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.styles.paragraph.clearStyle".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_style(
&self,
params: &DocStylesParagraphSetStyleBoundParams,
) -> Result<DocStylesParagraphSetStyleResult> {
self.set_style_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_style_with_options(
&self,
params: &DocStylesParagraphSetStyleBoundParams,
options: InvokeOptions,
) -> Result<DocStylesParagraphSetStyleResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.styles.paragraph.setStyle", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.styles.paragraph.setStyle".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_style_ref(
&self,
params: &DocStylesParagraphSetStyleRefBoundParams,
) -> Result<DocStylesParagraphSetStyleRefResult> {
self.set_style_ref_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_style_ref_with_options(
&self,
params: &DocStylesParagraphSetStyleRefBoundParams,
options: InvokeOptions,
) -> Result<DocStylesParagraphSetStyleRefResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.styles.paragraph.setStyleRef", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.styles.paragraph.setStyleRef".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiTables<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiTables<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn apply_border_preset(
&self,
params: &DocTablesApplyBorderPresetBoundParams,
) -> Result<DocTablesApplyBorderPresetResult> {
self.apply_border_preset_with_options(params, InvokeOptions::default())
.await
}
pub async fn apply_border_preset_with_options(
&self,
params: &DocTablesApplyBorderPresetBoundParams,
options: InvokeOptions,
) -> Result<DocTablesApplyBorderPresetResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.applyBorderPreset", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.applyBorderPreset".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn apply_preset(
&self,
params: &DocTablesApplyPresetBoundParams,
) -> Result<DocTablesApplyPresetResult> {
self.apply_preset_with_options(params, InvokeOptions::default())
.await
}
pub async fn apply_preset_with_options(
&self,
params: &DocTablesApplyPresetBoundParams,
options: InvokeOptions,
) -> Result<DocTablesApplyPresetResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.applyPreset", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.applyPreset".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn apply_style(
&self,
params: &DocTablesApplyStyleBoundParams,
) -> Result<DocTablesApplyStyleResult> {
self.apply_style_with_options(params, InvokeOptions::default())
.await
}
pub async fn apply_style_with_options(
&self,
params: &DocTablesApplyStyleBoundParams,
options: InvokeOptions,
) -> Result<DocTablesApplyStyleResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.applyStyle", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.applyStyle".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn clear_border(
&self,
params: &DocTablesClearBorderBoundParams,
) -> Result<DocTablesClearBorderResult> {
self.clear_border_with_options(params, InvokeOptions::default())
.await
}
pub async fn clear_border_with_options(
&self,
params: &DocTablesClearBorderBoundParams,
options: InvokeOptions,
) -> Result<DocTablesClearBorderResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.clearBorder", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.clearBorder".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn clear_cell_spacing(
&self,
params: &DocTablesClearCellSpacingBoundParams,
) -> Result<DocTablesClearCellSpacingResult> {
self.clear_cell_spacing_with_options(params, InvokeOptions::default())
.await
}
pub async fn clear_cell_spacing_with_options(
&self,
params: &DocTablesClearCellSpacingBoundParams,
options: InvokeOptions,
) -> Result<DocTablesClearCellSpacingResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.clearCellSpacing", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.clearCellSpacing".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn clear_contents(
&self,
params: &DocTablesClearContentsBoundParams,
) -> Result<DocTablesClearContentsResult> {
self.clear_contents_with_options(params, InvokeOptions::default())
.await
}
pub async fn clear_contents_with_options(
&self,
params: &DocTablesClearContentsBoundParams,
options: InvokeOptions,
) -> Result<DocTablesClearContentsResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.clearContents", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.clearContents".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn clear_default_style(
&self,
params: &DocTablesClearDefaultStyleBoundParams,
) -> Result<DocTablesClearDefaultStyleResult> {
self.clear_default_style_with_options(params, InvokeOptions::default())
.await
}
pub async fn clear_default_style_with_options(
&self,
params: &DocTablesClearDefaultStyleBoundParams,
options: InvokeOptions,
) -> Result<DocTablesClearDefaultStyleResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.clearDefaultStyle", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.clearDefaultStyle".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn clear_shading(
&self,
params: &DocTablesClearShadingBoundParams,
) -> Result<DocTablesClearShadingResult> {
self.clear_shading_with_options(params, InvokeOptions::default())
.await
}
pub async fn clear_shading_with_options(
&self,
params: &DocTablesClearShadingBoundParams,
options: InvokeOptions,
) -> Result<DocTablesClearShadingResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.clearShading", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.clearShading".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn clear_style(
&self,
params: &DocTablesClearStyleBoundParams,
) -> Result<DocTablesClearStyleResult> {
self.clear_style_with_options(params, InvokeOptions::default())
.await
}
pub async fn clear_style_with_options(
&self,
params: &DocTablesClearStyleBoundParams,
options: InvokeOptions,
) -> Result<DocTablesClearStyleResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.clearStyle", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.clearStyle".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn convert_from_text(
&self,
params: &DocTablesConvertFromTextBoundParams,
) -> Result<DocTablesConvertFromTextResult> {
self.convert_from_text_with_options(params, InvokeOptions::default())
.await
}
pub async fn convert_from_text_with_options(
&self,
params: &DocTablesConvertFromTextBoundParams,
options: InvokeOptions,
) -> Result<DocTablesConvertFromTextResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.convertFromText", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.convertFromText".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn convert_to_text(
&self,
params: &DocTablesConvertToTextBoundParams,
) -> Result<DocTablesConvertToTextResult> {
self.convert_to_text_with_options(params, InvokeOptions::default())
.await
}
pub async fn convert_to_text_with_options(
&self,
params: &DocTablesConvertToTextBoundParams,
options: InvokeOptions,
) -> Result<DocTablesConvertToTextResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.convertToText", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.convertToText".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn delete(
&self,
params: &DocTablesDeleteBoundParams,
) -> Result<DocTablesDeleteResult> {
self.delete_with_options(params, InvokeOptions::default())
.await
}
pub async fn delete_with_options(
&self,
params: &DocTablesDeleteBoundParams,
options: InvokeOptions,
) -> Result<DocTablesDeleteResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.delete", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.delete".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn delete_cell(
&self,
params: &DocTablesDeleteCellBoundParams,
) -> Result<DocTablesDeleteCellResult> {
self.delete_cell_with_options(params, InvokeOptions::default())
.await
}
pub async fn delete_cell_with_options(
&self,
params: &DocTablesDeleteCellBoundParams,
options: InvokeOptions,
) -> Result<DocTablesDeleteCellResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.deleteCell", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.deleteCell".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn delete_column(
&self,
params: &DocTablesDeleteColumnBoundParams,
) -> Result<DocTablesDeleteColumnResult> {
self.delete_column_with_options(params, InvokeOptions::default())
.await
}
pub async fn delete_column_with_options(
&self,
params: &DocTablesDeleteColumnBoundParams,
options: InvokeOptions,
) -> Result<DocTablesDeleteColumnResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.deleteColumn", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.deleteColumn".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn delete_row(
&self,
params: &DocTablesDeleteRowBoundParams,
) -> Result<DocTablesDeleteRowResult> {
self.delete_row_with_options(params, InvokeOptions::default())
.await
}
pub async fn delete_row_with_options(
&self,
params: &DocTablesDeleteRowBoundParams,
options: InvokeOptions,
) -> Result<DocTablesDeleteRowResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.deleteRow", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.deleteRow".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn distribute_columns(
&self,
params: &DocTablesDistributeColumnsBoundParams,
) -> Result<DocTablesDistributeColumnsResult> {
self.distribute_columns_with_options(params, InvokeOptions::default())
.await
}
pub async fn distribute_columns_with_options(
&self,
params: &DocTablesDistributeColumnsBoundParams,
options: InvokeOptions,
) -> Result<DocTablesDistributeColumnsResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.distributeColumns", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.distributeColumns".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn distribute_rows(
&self,
params: &DocTablesDistributeRowsBoundParams,
) -> Result<DocTablesDistributeRowsResult> {
self.distribute_rows_with_options(params, InvokeOptions::default())
.await
}
pub async fn distribute_rows_with_options(
&self,
params: &DocTablesDistributeRowsBoundParams,
options: InvokeOptions,
) -> Result<DocTablesDistributeRowsResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.distributeRows", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.distributeRows".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn get(&self, params: &DocTablesGetBoundParams) -> Result<DocTablesGetResult> {
self.get_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_with_options(
&self,
params: &DocTablesGetBoundParams,
options: InvokeOptions,
) -> Result<DocTablesGetResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.get", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.get".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn get_cells(
&self,
params: &DocTablesGetCellsBoundParams,
) -> Result<DocTablesGetCellsResult> {
self.get_cells_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_cells_with_options(
&self,
params: &DocTablesGetCellsBoundParams,
options: InvokeOptions,
) -> Result<DocTablesGetCellsResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.getCells", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.getCells".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn get_properties(
&self,
params: &DocTablesGetPropertiesBoundParams,
) -> Result<DocTablesGetPropertiesResult> {
self.get_properties_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_properties_with_options(
&self,
params: &DocTablesGetPropertiesBoundParams,
options: InvokeOptions,
) -> Result<DocTablesGetPropertiesResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.getProperties", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.getProperties".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn get_styles(
&self,
params: &DocTablesGetStylesBoundParams,
) -> Result<DocTablesGetStylesResult> {
self.get_styles_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_styles_with_options(
&self,
params: &DocTablesGetStylesBoundParams,
options: InvokeOptions,
) -> Result<DocTablesGetStylesResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.getStyles", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.getStyles".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn insert_cell(
&self,
params: &DocTablesInsertCellBoundParams,
) -> Result<DocTablesInsertCellResult> {
self.insert_cell_with_options(params, InvokeOptions::default())
.await
}
pub async fn insert_cell_with_options(
&self,
params: &DocTablesInsertCellBoundParams,
options: InvokeOptions,
) -> Result<DocTablesInsertCellResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.insertCell", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.insertCell".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn insert_column(
&self,
params: &DocTablesInsertColumnBoundParams,
) -> Result<DocTablesInsertColumnResult> {
self.insert_column_with_options(params, InvokeOptions::default())
.await
}
pub async fn insert_column_with_options(
&self,
params: &DocTablesInsertColumnBoundParams,
options: InvokeOptions,
) -> Result<DocTablesInsertColumnResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.insertColumn", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.insertColumn".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn insert_row(
&self,
params: &DocTablesInsertRowBoundParams,
) -> Result<DocTablesInsertRowResult> {
self.insert_row_with_options(params, InvokeOptions::default())
.await
}
pub async fn insert_row_with_options(
&self,
params: &DocTablesInsertRowBoundParams,
options: InvokeOptions,
) -> Result<DocTablesInsertRowResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.insertRow", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.insertRow".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn merge_cells(
&self,
params: &DocTablesMergeCellsBoundParams,
) -> Result<DocTablesMergeCellsResult> {
self.merge_cells_with_options(params, InvokeOptions::default())
.await
}
pub async fn merge_cells_with_options(
&self,
params: &DocTablesMergeCellsBoundParams,
options: InvokeOptions,
) -> Result<DocTablesMergeCellsResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.mergeCells", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.mergeCells".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn move_(&self, params: &DocTablesMoveBoundParams) -> Result<DocTablesMoveResult> {
self.move_with_options(params, InvokeOptions::default())
.await
}
pub async fn move_with_options(
&self,
params: &DocTablesMoveBoundParams,
options: InvokeOptions,
) -> Result<DocTablesMoveResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.move", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.move".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn move_column(
&self,
params: &DocTablesMoveColumnBoundParams,
) -> Result<DocTablesMoveColumnResult> {
self.move_column_with_options(params, InvokeOptions::default())
.await
}
pub async fn move_column_with_options(
&self,
params: &DocTablesMoveColumnBoundParams,
options: InvokeOptions,
) -> Result<DocTablesMoveColumnResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.moveColumn", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.moveColumn".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn move_row(
&self,
params: &DocTablesMoveRowBoundParams,
) -> Result<DocTablesMoveRowResult> {
self.move_row_with_options(params, InvokeOptions::default())
.await
}
pub async fn move_row_with_options(
&self,
params: &DocTablesMoveRowBoundParams,
options: InvokeOptions,
) -> Result<DocTablesMoveRowResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.moveRow", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.moveRow".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_alt_text(
&self,
params: &DocTablesSetAltTextBoundParams,
) -> Result<DocTablesSetAltTextResult> {
self.set_alt_text_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_alt_text_with_options(
&self,
params: &DocTablesSetAltTextBoundParams,
options: InvokeOptions,
) -> Result<DocTablesSetAltTextResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.setAltText", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.setAltText".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_border(
&self,
params: &DocTablesSetBorderBoundParams,
) -> Result<DocTablesSetBorderResult> {
self.set_border_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_border_with_options(
&self,
params: &DocTablesSetBorderBoundParams,
options: InvokeOptions,
) -> Result<DocTablesSetBorderResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.setBorder", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.setBorder".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_borders(
&self,
params: &DocTablesSetBordersBoundParams,
) -> Result<DocTablesSetBordersResult> {
self.set_borders_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_borders_with_options(
&self,
params: &DocTablesSetBordersBoundParams,
options: InvokeOptions,
) -> Result<DocTablesSetBordersResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.setBorders", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.setBorders".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_cell_padding(
&self,
params: &DocTablesSetCellPaddingBoundParams,
) -> Result<DocTablesSetCellPaddingResult> {
self.set_cell_padding_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_cell_padding_with_options(
&self,
params: &DocTablesSetCellPaddingBoundParams,
options: InvokeOptions,
) -> Result<DocTablesSetCellPaddingResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.setCellPadding", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.setCellPadding".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_cell_properties(
&self,
params: &DocTablesSetCellPropertiesBoundParams,
) -> Result<DocTablesSetCellPropertiesResult> {
self.set_cell_properties_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_cell_properties_with_options(
&self,
params: &DocTablesSetCellPropertiesBoundParams,
options: InvokeOptions,
) -> Result<DocTablesSetCellPropertiesResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.setCellProperties", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.setCellProperties".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_cell_spacing(
&self,
params: &DocTablesSetCellSpacingBoundParams,
) -> Result<DocTablesSetCellSpacingResult> {
self.set_cell_spacing_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_cell_spacing_with_options(
&self,
params: &DocTablesSetCellSpacingBoundParams,
options: InvokeOptions,
) -> Result<DocTablesSetCellSpacingResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.setCellSpacing", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.setCellSpacing".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_cell_text(
&self,
params: &DocTablesSetCellTextBoundParams,
) -> Result<DocTablesSetCellTextResult> {
self.set_cell_text_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_cell_text_with_options(
&self,
params: &DocTablesSetCellTextBoundParams,
options: InvokeOptions,
) -> Result<DocTablesSetCellTextResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.setCellText", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.setCellText".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_column_width(
&self,
params: &DocTablesSetColumnWidthBoundParams,
) -> Result<DocTablesSetColumnWidthResult> {
self.set_column_width_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_column_width_with_options(
&self,
params: &DocTablesSetColumnWidthBoundParams,
options: InvokeOptions,
) -> Result<DocTablesSetColumnWidthResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.setColumnWidth", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.setColumnWidth".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_default_style(
&self,
params: &DocTablesSetDefaultStyleBoundParams,
) -> Result<DocTablesSetDefaultStyleResult> {
self.set_default_style_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_default_style_with_options(
&self,
params: &DocTablesSetDefaultStyleBoundParams,
options: InvokeOptions,
) -> Result<DocTablesSetDefaultStyleResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.setDefaultStyle", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.setDefaultStyle".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_layout(
&self,
params: &DocTablesSetLayoutBoundParams,
) -> Result<DocTablesSetLayoutResult> {
self.set_layout_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_layout_with_options(
&self,
params: &DocTablesSetLayoutBoundParams,
options: InvokeOptions,
) -> Result<DocTablesSetLayoutResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.setLayout", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.setLayout".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_row_height(
&self,
params: &DocTablesSetRowHeightBoundParams,
) -> Result<DocTablesSetRowHeightResult> {
self.set_row_height_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_row_height_with_options(
&self,
params: &DocTablesSetRowHeightBoundParams,
options: InvokeOptions,
) -> Result<DocTablesSetRowHeightResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.setRowHeight", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.setRowHeight".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_row_options(
&self,
params: &DocTablesSetRowOptionsBoundParams,
) -> Result<DocTablesSetRowOptionsResult> {
self.set_row_options_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_row_options_with_options(
&self,
params: &DocTablesSetRowOptionsBoundParams,
options: InvokeOptions,
) -> Result<DocTablesSetRowOptionsResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.setRowOptions", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.setRowOptions".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_shading(
&self,
params: &DocTablesSetShadingBoundParams,
) -> Result<DocTablesSetShadingResult> {
self.set_shading_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_shading_with_options(
&self,
params: &DocTablesSetShadingBoundParams,
options: InvokeOptions,
) -> Result<DocTablesSetShadingResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.setShading", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.setShading".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_style(
&self,
params: &DocTablesSetStyleBoundParams,
) -> Result<DocTablesSetStyleResult> {
self.set_style_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_style_with_options(
&self,
params: &DocTablesSetStyleBoundParams,
options: InvokeOptions,
) -> Result<DocTablesSetStyleResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.setStyle", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.setStyle".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_style_option(
&self,
params: &DocTablesSetStyleOptionBoundParams,
) -> Result<DocTablesSetStyleOptionResult> {
self.set_style_option_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_style_option_with_options(
&self,
params: &DocTablesSetStyleOptionBoundParams,
options: InvokeOptions,
) -> Result<DocTablesSetStyleOptionResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.setStyleOption", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.setStyleOption".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_table_options(
&self,
params: &DocTablesSetTableOptionsBoundParams,
) -> Result<DocTablesSetTableOptionsResult> {
self.set_table_options_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_table_options_with_options(
&self,
params: &DocTablesSetTableOptionsBoundParams,
options: InvokeOptions,
) -> Result<DocTablesSetTableOptionsResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.setTableOptions", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.setTableOptions".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn set_table_padding(
&self,
params: &DocTablesSetTablePaddingBoundParams,
) -> Result<DocTablesSetTablePaddingResult> {
self.set_table_padding_with_options(params, InvokeOptions::default())
.await
}
pub async fn set_table_padding_with_options(
&self,
params: &DocTablesSetTablePaddingBoundParams,
options: InvokeOptions,
) -> Result<DocTablesSetTablePaddingResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.setTablePadding", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.setTablePadding".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn sort(&self, params: &DocTablesSortBoundParams) -> Result<DocTablesSortResult> {
self.sort_with_options(params, InvokeOptions::default())
.await
}
pub async fn sort_with_options(
&self,
params: &DocTablesSortBoundParams,
options: InvokeOptions,
) -> Result<DocTablesSortResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.sort", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.sort".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn split(&self, params: &DocTablesSplitBoundParams) -> Result<DocTablesSplitResult> {
self.split_with_options(params, InvokeOptions::default())
.await
}
pub async fn split_with_options(
&self,
params: &DocTablesSplitBoundParams,
options: InvokeOptions,
) -> Result<DocTablesSplitResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.split", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.split".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn split_cell(
&self,
params: &DocTablesSplitCellBoundParams,
) -> Result<DocTablesSplitCellResult> {
self.split_cell_with_options(params, InvokeOptions::default())
.await
}
pub async fn split_cell_with_options(
&self,
params: &DocTablesSplitCellBoundParams,
options: InvokeOptions,
) -> Result<DocTablesSplitCellResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.splitCell", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.splitCell".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn unmerge_cells(
&self,
params: &DocTablesUnmergeCellsBoundParams,
) -> Result<DocTablesUnmergeCellsResult> {
self.unmerge_cells_with_options(params, InvokeOptions::default())
.await
}
pub async fn unmerge_cells_with_options(
&self,
params: &DocTablesUnmergeCellsBoundParams,
options: InvokeOptions,
) -> Result<DocTablesUnmergeCellsResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.tables.unmergeCells", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.tables.unmergeCells".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiTemplates<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiTemplates<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn apply(
&self,
params: &DocTemplatesApplyBoundParams,
) -> Result<DocTemplatesApplyResult> {
self.apply_with_options(params, InvokeOptions::default())
.await
}
pub async fn apply_with_options(
&self,
params: &DocTemplatesApplyBoundParams,
options: InvokeOptions,
) -> Result<DocTemplatesApplyResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.templates.apply", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.templates.apply".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiToc<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiToc<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn configure(
&self,
params: &DocTocConfigureBoundParams,
) -> Result<DocTocConfigureResult> {
self.configure_with_options(params, InvokeOptions::default())
.await
}
pub async fn configure_with_options(
&self,
params: &DocTocConfigureBoundParams,
options: InvokeOptions,
) -> Result<DocTocConfigureResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.toc.configure", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.toc.configure".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn edit_entry(
&self,
params: &DocTocEditEntryBoundParams,
) -> Result<DocTocEditEntryResult> {
self.edit_entry_with_options(params, InvokeOptions::default())
.await
}
pub async fn edit_entry_with_options(
&self,
params: &DocTocEditEntryBoundParams,
options: InvokeOptions,
) -> Result<DocTocEditEntryResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.toc.editEntry", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.toc.editEntry".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn get(&self, params: &DocTocGetBoundParams) -> Result<DocTocGetResult> {
self.get_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_with_options(
&self,
params: &DocTocGetBoundParams,
options: InvokeOptions,
) -> Result<DocTocGetResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self.invoker.invoke("doc.toc.get", params, options).await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.toc.get".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn get_entry(
&self,
params: &DocTocGetEntryBoundParams,
) -> Result<DocTocGetEntryResult> {
self.get_entry_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_entry_with_options(
&self,
params: &DocTocGetEntryBoundParams,
options: InvokeOptions,
) -> Result<DocTocGetEntryResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.toc.getEntry", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.toc.getEntry".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn list(&self, params: &DocTocListBoundParams) -> Result<DocTocListResult> {
self.list_with_options(params, InvokeOptions::default())
.await
}
pub async fn list_with_options(
&self,
params: &DocTocListBoundParams,
options: InvokeOptions,
) -> Result<DocTocListResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self.invoker.invoke("doc.toc.list", params, options).await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.toc.list".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn list_entries(
&self,
params: &DocTocListEntriesBoundParams,
) -> Result<DocTocListEntriesResult> {
self.list_entries_with_options(params, InvokeOptions::default())
.await
}
pub async fn list_entries_with_options(
&self,
params: &DocTocListEntriesBoundParams,
options: InvokeOptions,
) -> Result<DocTocListEntriesResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.toc.listEntries", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.toc.listEntries".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn mark_entry(
&self,
params: &DocTocMarkEntryBoundParams,
) -> Result<DocTocMarkEntryResult> {
self.mark_entry_with_options(params, InvokeOptions::default())
.await
}
pub async fn mark_entry_with_options(
&self,
params: &DocTocMarkEntryBoundParams,
options: InvokeOptions,
) -> Result<DocTocMarkEntryResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.toc.markEntry", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.toc.markEntry".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn remove(&self, params: &DocTocRemoveBoundParams) -> Result<DocTocRemoveResult> {
self.remove_with_options(params, InvokeOptions::default())
.await
}
pub async fn remove_with_options(
&self,
params: &DocTocRemoveBoundParams,
options: InvokeOptions,
) -> Result<DocTocRemoveResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.toc.remove", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.toc.remove".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn unmark_entry(
&self,
params: &DocTocUnmarkEntryBoundParams,
) -> Result<DocTocUnmarkEntryResult> {
self.unmark_entry_with_options(params, InvokeOptions::default())
.await
}
pub async fn unmark_entry_with_options(
&self,
params: &DocTocUnmarkEntryBoundParams,
options: InvokeOptions,
) -> Result<DocTocUnmarkEntryResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.toc.unmarkEntry", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.toc.unmarkEntry".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn update(&self, params: &DocTocUpdateBoundParams) -> Result<DocTocUpdateResult> {
self.update_with_options(params, InvokeOptions::default())
.await
}
pub async fn update_with_options(
&self,
params: &DocTocUpdateBoundParams,
options: InvokeOptions,
) -> Result<DocTocUpdateResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.toc.update", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.toc.update".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub struct DocApiTrackChanges<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiTrackChanges<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn decide(
&self,
params: &DocTrackChangesDecideBoundParams,
) -> Result<DocTrackChangesDecideResult> {
self.decide_with_options(params, InvokeOptions::default())
.await
}
pub async fn decide_with_options(
&self,
params: &DocTrackChangesDecideBoundParams,
options: InvokeOptions,
) -> Result<DocTrackChangesDecideResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.trackChanges.decide", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.trackChanges.decide".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn get(
&self,
params: &DocTrackChangesGetBoundParams,
) -> Result<DocTrackChangesGetResult> {
self.get_with_options(params, InvokeOptions::default())
.await
}
pub async fn get_with_options(
&self,
params: &DocTrackChangesGetBoundParams,
options: InvokeOptions,
) -> Result<DocTrackChangesGetResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.trackChanges.get", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.trackChanges.get".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn list(
&self,
params: &DocTrackChangesListBoundParams,
) -> Result<DocTrackChangesListResult> {
self.list_with_options(params, InvokeOptions::default())
.await
}
pub async fn list_with_options(
&self,
params: &DocTrackChangesListBoundParams,
options: InvokeOptions,
) -> Result<DocTrackChangesListResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.trackChanges.list", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.trackChanges.list".to_owned());
error.outcome_unknown = false;
error
})
}
}
pub struct DocApiWatermarks<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> DocApiWatermarks<'a, I> {
pub fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub async fn apply(
&self,
params: &DocWatermarksApplyBoundParams,
) -> Result<DocWatermarksApplyResult> {
self.apply_with_options(params, InvokeOptions::default())
.await
}
pub async fn apply_with_options(
&self,
params: &DocWatermarksApplyBoundParams,
options: InvokeOptions,
) -> Result<DocWatermarksApplyResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.watermarks.apply", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.watermarks.apply".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn insert(
&self,
params: &DocWatermarksInsertBoundParams,
) -> Result<DocWatermarksInsertResult> {
self.insert_with_options(params, InvokeOptions::default())
.await
}
pub async fn insert_with_options(
&self,
params: &DocWatermarksInsertBoundParams,
options: InvokeOptions,
) -> Result<DocWatermarksInsertResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.watermarks.insert", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.watermarks.insert".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn list(
&self,
params: &DocWatermarksListBoundParams,
) -> Result<DocWatermarksListResult> {
self.list_with_options(params, InvokeOptions::default())
.await
}
pub async fn list_with_options(
&self,
params: &DocWatermarksListBoundParams,
options: InvokeOptions,
) -> Result<DocWatermarksListResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.watermarks.list", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.watermarks.list".to_owned());
error.outcome_unknown = false;
error
})
}
pub async fn remove(
&self,
params: &DocWatermarksRemoveBoundParams,
) -> Result<DocWatermarksRemoveResult> {
self.remove_with_options(params, InvokeOptions::default())
.await
}
pub async fn remove_with_options(
&self,
params: &DocWatermarksRemoveBoundParams,
options: InvokeOptions,
) -> Result<DocWatermarksRemoveResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.watermarks.remove", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.watermarks.remove".to_owned());
error.outcome_unknown = true;
error
})
}
pub async fn replace(
&self,
params: &DocWatermarksReplaceBoundParams,
) -> Result<DocWatermarksReplaceResult> {
self.replace_with_options(params, InvokeOptions::default())
.await
}
pub async fn replace_with_options(
&self,
params: &DocWatermarksReplaceBoundParams,
options: InvokeOptions,
) -> Result<DocWatermarksReplaceResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.watermarks.replace", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.watermarks.replace".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub(crate) struct ClientApi<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> ClientApi<'a, I> {
pub(crate) fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub(crate) async fn describe(&self, params: &DocDescribeParams) -> Result<DocDescribeResult> {
self.describe_with_options(params, InvokeOptions::default())
.await
}
pub(crate) async fn describe_with_options(
&self,
params: &DocDescribeParams,
options: InvokeOptions,
) -> Result<DocDescribeResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self.invoker.invoke("doc.describe", params, options).await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.describe".to_owned());
error.outcome_unknown = false;
error
})
}
pub(crate) async fn describe_command(
&self,
params: &DocDescribeCommandParams,
) -> Result<DocDescribeCommandResult> {
self.describe_command_with_options(params, InvokeOptions::default())
.await
}
pub(crate) async fn describe_command_with_options(
&self,
params: &DocDescribeCommandParams,
options: InvokeOptions,
) -> Result<DocDescribeCommandResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.describeCommand", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.describeCommand".to_owned());
error.outcome_unknown = false;
error
})
}
pub(crate) async fn open(&self, params: &DocOpenParams) -> Result<DocOpenResult> {
self.open_with_options(params, InvokeOptions::default())
.await
}
pub(crate) async fn open_with_options(
&self,
params: &DocOpenParams,
options: InvokeOptions,
) -> Result<DocOpenResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self.invoker.invoke("doc.open", params, options).await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.open".to_owned());
error.outcome_unknown = true;
error
})
}
}
pub(crate) struct InternalApi<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> InternalApi<'a, I> {
pub(crate) fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub(crate) fn session(&self) -> InternalApiSession<'a, I> {
InternalApiSession::new(self.invoker)
}
pub(crate) async fn discover(&self, params: &DocDiscoverParams) -> Result<DocDiscoverResult> {
self.discover_with_options(params, InvokeOptions::default())
.await
}
pub(crate) async fn discover_with_options(
&self,
params: &DocDiscoverParams,
options: InvokeOptions,
) -> Result<DocDiscoverResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self.invoker.invoke("doc.discover", params, options).await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.discover".to_owned());
error.outcome_unknown = false;
error
})
}
pub(crate) async fn status(&self, params: &DocStatusParams) -> Result<DocStatusResult> {
self.status_with_options(params, InvokeOptions::default())
.await
}
pub(crate) async fn status_with_options(
&self,
params: &DocStatusParams,
options: InvokeOptions,
) -> Result<DocStatusResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self.invoker.invoke("doc.status", params, options).await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.status".to_owned());
error.outcome_unknown = false;
error
})
}
}
pub(crate) struct InternalApiSession<'a, I: Invoker> {
invoker: &'a I,
}
impl<'a, I: Invoker> InternalApiSession<'a, I> {
pub(crate) fn new(invoker: &'a I) -> Self {
Self { invoker }
}
pub(crate) async fn close(
&self,
params: &DocSessionCloseParams,
) -> Result<DocSessionCloseResult> {
self.close_with_options(params, InvokeOptions::default())
.await
}
pub(crate) async fn close_with_options(
&self,
params: &DocSessionCloseParams,
options: InvokeOptions,
) -> Result<DocSessionCloseResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.session.close", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.session.close".to_owned());
error.outcome_unknown = true;
error
})
}
pub(crate) async fn list(&self, params: &DocSessionListParams) -> Result<DocSessionListResult> {
self.list_with_options(params, InvokeOptions::default())
.await
}
pub(crate) async fn list_with_options(
&self,
params: &DocSessionListParams,
options: InvokeOptions,
) -> Result<DocSessionListResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.session.list", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.session.list".to_owned());
error.outcome_unknown = false;
error
})
}
pub(crate) async fn save(&self, params: &DocSessionSaveParams) -> Result<DocSessionSaveResult> {
self.save_with_options(params, InvokeOptions::default())
.await
}
pub(crate) async fn save_with_options(
&self,
params: &DocSessionSaveParams,
options: InvokeOptions,
) -> Result<DocSessionSaveResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.session.save", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.session.save".to_owned());
error.outcome_unknown = true;
error
})
}
pub(crate) async fn set_default(
&self,
params: &DocSessionSetDefaultParams,
) -> Result<DocSessionSetDefaultResult> {
self.set_default_with_options(params, InvokeOptions::default())
.await
}
pub(crate) async fn set_default_with_options(
&self,
params: &DocSessionSetDefaultParams,
options: InvokeOptions,
) -> Result<DocSessionSetDefaultResult> {
let params = serde_json::to_value(params)
.map_err(|error| Error::new("INVALID_ARGUMENT", error.to_string()))?;
let result = self
.invoker
.invoke("doc.session.setDefault", params, options)
.await?;
serde_json::from_value(result).map_err(|decode| {
let mut error = Error::decode(decode);
error.operation_id = Some("doc.session.setDefault".to_owned());
error.outcome_unknown = true;
error
})
}
}
#[cfg(any(test, feature = "conformance"))]
pub(crate) async fn exercise_callables<I: Invoker>(invoker: &I) {
{
let params:DocAuthoritiesConfigureBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"tableOfAuthorities\",\"nodeId\":\"\"},\"patch\":{}}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).authorities().configure(¶ms).await;
}
{
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");
let _ = DocApi::new(invoker)
.authorities()
.entries()
.get(¶ms)
.await;
}
{
let params:DocAuthoritiesEntriesInsertBoundParams=serde_json::from_str("{\"at\":{\"kind\":\"text\",\"segments\":[]},\"entry\":{\"longCitation\":\"\",\"category\":\"\"}}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.authorities()
.entries()
.insert(¶ms)
.await;
}
{
let params: DocAuthoritiesEntriesListBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.authorities()
.entries()
.list(¶ms)
.await;
}
{
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");
let _ = DocApi::new(invoker)
.authorities()
.entries()
.remove(¶ms)
.await;
}
{
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");
let _ = DocApi::new(invoker)
.authorities()
.entries()
.update(¶ms)
.await;
}
{
let params: DocAuthoritiesGetBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"tableOfAuthorities\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).authorities().get(¶ms).await;
}
{
let params: DocAuthoritiesInsertBoundParams =
serde_json::from_str("{\"at\":{\"kind\":\"documentStart\"}}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).authorities().insert(¶ms).await;
}
{
let params: DocAuthoritiesListBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).authorities().list(¶ms).await;
}
{
let params: DocAuthoritiesRebuildBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"tableOfAuthorities\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).authorities().rebuild(¶ms).await;
}
{
let params: DocAuthoritiesRemoveBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"tableOfAuthorities\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).authorities().remove(¶ms).await;
}
{
let params: DocBlocksDeleteBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).blocks().delete(¶ms).await;
}
{
let params: DocBlocksDeleteRangeBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).blocks().delete_range(¶ms).await;
}
{
let params: DocBlocksFindTextBoundParams =
serde_json::from_str("{\"text\":\"\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).blocks().find_text(¶ms).await;
}
{
let params: DocBlocksListBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).blocks().list(¶ms).await;
}
{
let params:DocBlocksMergeBoundParams=serde_json::from_str("{\"first\":{\"kind\":\"block\",\"nodeType\":\"paragraph\",\"nodeId\":\"\"},\"second\":{\"kind\":\"block\",\"nodeType\":\"paragraph\",\"nodeId\":\"\"}}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).blocks().merge(¶ms).await;
}
{
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");
let _ = DocApi::new(invoker).blocks().move_(¶ms).await;
}
{
let params:DocBlocksSplitBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"paragraph\",\"nodeId\":\"\"},\"offset\":0}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).blocks().split(¶ms).await;
}
{
let params: DocBookmarksGetBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"entity\",\"entityType\":\"bookmark\",\"name\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).bookmarks().get(¶ms).await;
}
{
let params: DocBookmarksInsertBoundParams =
serde_json::from_str("{\"name\":\"\",\"at\":{\"kind\":\"text\",\"segments\":[]}}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).bookmarks().insert(¶ms).await;
}
{
let params: DocBookmarksListBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).bookmarks().list(¶ms).await;
}
{
let params: DocBookmarksRemoveBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"entity\",\"entityType\":\"bookmark\",\"name\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).bookmarks().remove(¶ms).await;
}
{
let params:DocBookmarksRenameBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"entity\",\"entityType\":\"bookmark\",\"name\":\"\"},\"newName\":\"\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).bookmarks().rename(¶ms).await;
}
{
let params: DocCapabilitiesCheckBoundParams =
serde_json::from_str("{\"operation\":\"insert\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).capabilities().check(¶ms).await;
}
{
let params: DocCapabilitiesGetBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).capabilities().get(¶ms).await;
}
{
let params: DocCapabilitiesResolveBoundParams =
serde_json::from_str("{\"operationId\":\"get\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).capabilities().resolve(¶ms).await;
}
{
let params: DocCaptionsConfigureBoundParams = serde_json::from_str("{\"label\":\"\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).captions().configure(¶ms).await;
}
{
let params: DocCaptionsGetBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"paragraph\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).captions().get(¶ms).await;
}
{
let params:DocCaptionsInsertBoundParams=serde_json::from_str("{\"adjacentTo\":{\"kind\":\"block\",\"nodeType\":\"paragraph\",\"nodeId\":\"\"},\"position\":\"above\",\"label\":\"\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).captions().insert(¶ms).await;
}
{
let params: DocCaptionsListBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).captions().list(¶ms).await;
}
{
let params: DocCaptionsRemoveBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"paragraph\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).captions().remove(¶ms).await;
}
{
let params:DocCaptionsUpdateBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"paragraph\",\"nodeId\":\"\"},\"patch\":{}}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).captions().update(¶ms).await;
}
{
let params:DocCitationsBibliographyConfigureBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"bibliography\",\"nodeId\":\"\"},\"style\":\"\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.citations()
.bibliography()
.configure(¶ms)
.await;
}
{
let params: DocCitationsBibliographyGetBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"bibliography\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.citations()
.bibliography()
.get(¶ms)
.await;
}
{
let params: DocCitationsBibliographyInsertBoundParams =
serde_json::from_str("{\"at\":{\"kind\":\"documentStart\"}}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.citations()
.bibliography()
.insert(¶ms)
.await;
}
{
let params: DocCitationsBibliographyRebuildBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"bibliography\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.citations()
.bibliography()
.rebuild(¶ms)
.await;
}
{
let params: DocCitationsBibliographyRemoveBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"bibliography\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.citations()
.bibliography()
.remove(¶ms)
.await;
}
{
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");
let _ = DocApi::new(invoker).citations().get(¶ms).await;
}
{
let params: DocCitationsInsertBoundParams =
serde_json::from_str("{\"at\":{\"kind\":\"text\",\"segments\":[]},\"sourceIds\":[]}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).citations().insert(¶ms).await;
}
{
let params: DocCitationsListBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).citations().list(¶ms).await;
}
{
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");
let _ = DocApi::new(invoker).citations().remove(¶ms).await;
}
{
let params:DocCitationsSourcesGetBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"entity\",\"entityType\":\"citationSource\",\"sourceId\":\"\"}}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.citations()
.sources()
.get(¶ms)
.await;
}
{
let params: DocCitationsSourcesInsertBoundParams =
serde_json::from_str("{\"type\":\"book\",\"fields\":{}}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.citations()
.sources()
.insert(¶ms)
.await;
}
{
let params: DocCitationsSourcesListBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.citations()
.sources()
.list(¶ms)
.await;
}
{
let params:DocCitationsSourcesRemoveBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"entity\",\"entityType\":\"citationSource\",\"sourceId\":\"\"}}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.citations()
.sources()
.remove(¶ms)
.await;
}
{
let params:DocCitationsSourcesUpdateBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"entity\",\"entityType\":\"citationSource\",\"sourceId\":\"\"},\"patch\":{}}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.citations()
.sources()
.update(¶ms)
.await;
}
{
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");
let _ = DocApi::new(invoker).citations().update(¶ms).await;
}
{
let params: DocClearContentBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).clear_content(¶ms).await;
}
{
let params: DocClipboardInsertBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).clipboard().insert(¶ms).await;
}
{
let params: DocClipboardParseBoundParams =
serde_json::from_str("{\"items\":[]}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).clipboard().parse(¶ms).await;
}
{
let params: DocClipboardSerializeSelectionBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.clipboard()
.serialize_selection(¶ms)
.await;
}
{
let params: DocCloseBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).close(¶ms).await;
}
{
let params: DocCommentsCreateBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).comments().create(¶ms).await;
}
{
let params: DocCommentsDeleteBoundParams =
serde_json::from_str("{\"id\":\"\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).comments().delete(¶ms).await;
}
{
let params: DocCommentsGetBoundParams =
serde_json::from_str("{\"id\":\"\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).comments().get(¶ms).await;
}
{
let params: DocCommentsListBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).comments().list(¶ms).await;
}
{
let params: DocCommentsPatchBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).comments().patch(¶ms).await;
}
{
let params:DocContentControlsAppendContentBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"content\":\"\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.append_content(¶ms)
.await;
}
{
let params: DocContentControlsCheckboxGetStateBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.checkbox()
.get_state(¶ms)
.await;
}
{
let params:DocContentControlsCheckboxSetStateBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"checked\":false}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.checkbox()
.set_state(¶ms)
.await;
}
{
let params:DocContentControlsCheckboxSetSymbolPairBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"checkedSymbol\":{},\"uncheckedSymbol\":{}}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.checkbox()
.set_symbol_pair(¶ms)
.await;
}
{
let params: DocContentControlsCheckboxToggleBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.checkbox()
.toggle(¶ms)
.await;
}
{
let params: DocContentControlsChoiceListGetItemsBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.choice_list()
.get_items(¶ms)
.await;
}
{
let params: DocContentControlsChoiceListSetItemsBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"items\":[]}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.choice_list()
.set_items(¶ms)
.await;
}
{
let params: DocContentControlsChoiceListSetSelectedBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"value\":\"\"}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.choice_list()
.set_selected(¶ms)
.await;
}
{
let params: DocContentControlsClearBindingBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.clear_binding(¶ms)
.await;
}
{
let params: DocContentControlsClearContentBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.clear_content(¶ms)
.await;
}
{
let params:DocContentControlsCopyBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"destination\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).content_controls().copy(¶ms).await;
}
{
let params: DocContentControlsDateClearValueBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.date()
.clear_value(¶ms)
.await;
}
{
let params:DocContentControlsDateSetCalendarBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"calendar\":\"\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.date()
.set_calendar(¶ms)
.await;
}
{
let params:DocContentControlsDateSetDisplayFormatBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"format\":\"\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.date()
.set_display_format(¶ms)
.await;
}
{
let params:DocContentControlsDateSetDisplayLocaleBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"locale\":\"\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.date()
.set_display_locale(¶ms)
.await;
}
{
let params:DocContentControlsDateSetStorageFormatBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"format\":\"\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.date()
.set_storage_format(¶ms)
.await;
}
{
let params: DocContentControlsDateSetValueBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"value\":\"\"}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.date()
.set_value(¶ms)
.await;
}
{
let params: DocContentControlsDeleteBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.delete(¶ms)
.await;
}
{
let params: DocContentControlsGetBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).content_controls().get(¶ms).await;
}
{
let params: DocContentControlsGetBindingBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.get_binding(¶ms)
.await;
}
{
let params: DocContentControlsGetContentBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.get_content(¶ms)
.await;
}
{
let params: DocContentControlsGetParentBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.get_parent(¶ms)
.await;
}
{
let params: DocContentControlsGetRawPropertiesBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.get_raw_properties(¶ms)
.await;
}
{
let params: DocContentControlsGroupUngroupBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.group()
.ungroup(¶ms)
.await;
}
{
let params: DocContentControlsGroupWrapBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.group()
.wrap(¶ms)
.await;
}
{
let params:DocContentControlsInsertAfterBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"content\":\"\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.insert_after(¶ms)
.await;
}
{
let params:DocContentControlsInsertBeforeBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"content\":\"\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.insert_before(¶ms)
.await;
}
{
let params: DocContentControlsListBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).content_controls().list(¶ms).await;
}
{
let params: DocContentControlsListChildrenBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.list_children(¶ms)
.await;
}
{
let params: DocContentControlsListInRangeBoundParams =
serde_json::from_str("{\"startBlockId\":\"\",\"endBlockId\":\"\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.list_in_range(¶ms)
.await;
}
{
let params:DocContentControlsMoveBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"destination\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).content_controls().move_(¶ms).await;
}
{
let params: DocContentControlsNormalizeTagPayloadBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.normalize_tag_payload(¶ms)
.await;
}
{
let params: DocContentControlsNormalizeWordCompatibilityBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.normalize_word_compatibility(¶ms)
.await;
}
{
let params: DocContentControlsPatchBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).content_controls().patch(¶ms).await;
}
{
let params: DocContentControlsPatchRawPropertiesBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"patches\":[]}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.patch_raw_properties(¶ms)
.await;
}
{
let params:DocContentControlsPrependContentBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"content\":\"\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.prepend_content(¶ms)
.await;
}
{
let params: DocContentControlsRepeatingSectionCloneItemBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"index\":0}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.repeating_section()
.clone_item(¶ms)
.await;
}
{
let params: DocContentControlsRepeatingSectionDeleteItemBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"index\":0}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.repeating_section()
.delete_item(¶ms)
.await;
}
{
let params:DocContentControlsRepeatingSectionInsertItemAfterBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"index\":0}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.repeating_section()
.insert_item_after(¶ms)
.await;
}
{
let params:DocContentControlsRepeatingSectionInsertItemBeforeBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"index\":0}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.repeating_section()
.insert_item_before(¶ms)
.await;
}
{
let params: DocContentControlsRepeatingSectionListItemsBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.repeating_section()
.list_items(¶ms)
.await;
}
{
let params:DocContentControlsRepeatingSectionSetAllowInsertDeleteBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"allow\":false}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.repeating_section()
.set_allow_insert_delete(¶ms)
.await;
}
{
let params:DocContentControlsReplaceContentBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"content\":\"\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.replace_content(¶ms)
.await;
}
{
let params: DocContentControlsSelectByTagBoundParams =
serde_json::from_str("{\"tag\":\"\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.select_by_tag(¶ms)
.await;
}
{
let params: DocContentControlsSelectByTitleBoundParams =
serde_json::from_str("{\"title\":\"\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.select_by_title(¶ms)
.await;
}
{
let params:DocContentControlsSetBindingBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"storeItemId\":\"\",\"xpath\":\"\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.set_binding(¶ms)
.await;
}
{
let params:DocContentControlsSetLockModeBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"lockMode\":\"unlocked\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.set_lock_mode(¶ms)
.await;
}
{
let params:DocContentControlsSetTypeBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"controlType\":\"\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.set_type(¶ms)
.await;
}
{
let params: DocContentControlsTextClearValueBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.text()
.clear_value(¶ms)
.await;
}
{
let params:DocContentControlsTextSetMultilineBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"multiline\":false}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.text()
.set_multiline(¶ms)
.await;
}
{
let params: DocContentControlsTextSetValueBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"},\"value\":\"\"}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.text()
.set_value(¶ms)
.await;
}
{
let params: DocContentControlsUnwrapBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.unwrap(¶ms)
.await;
}
{
let params: DocContentControlsValidateWordCompatibilityBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.content_controls()
.validate_word_compatibility(¶ms)
.await;
}
{
let params:DocContentControlsWrapBoundParams=serde_json::from_str("{\"kind\":\"block\",\"target\":{\"kind\":\"block\",\"nodeType\":\"sdt\",\"nodeId\":\"\"}}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).content_controls().wrap(¶ms).await;
}
{
let params: DocCreateContentControlBoundParams =
serde_json::from_str("{\"kind\":\"block\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).create().content_control(¶ms).await;
}
{
let params: DocCreateHeadingBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).create().heading(¶ms).await;
}
{
let params: DocCreateImageBoundParams =
serde_json::from_str("{\"src\":\"\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).create().image(¶ms).await;
}
{
let params: DocCreateParagraphBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).create().paragraph(¶ms).await;
}
{
let params: DocCreateSectionBreakBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).create().section_break(¶ms).await;
}
{
let params: DocCreateTableBoundParams = serde_json::from_str("{\"rows\":0,\"columns\":0}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).create().table(¶ms).await;
}
{
let params: DocCreateTableOfContentsBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.create()
.table_of_contents(¶ms)
.await;
}
{
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");
let _ = DocApi::new(invoker).cross_refs().get(¶ms).await;
}
{
let params:DocCrossRefsInsertBoundParams=serde_json::from_str("{\"at\":{\"kind\":\"text\",\"segments\":[]},\"target\":{\"kind\":\"bookmark\",\"name\":\"\"},\"display\":\"content\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).cross_refs().insert(¶ms).await;
}
{
let params: DocCrossRefsListBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).cross_refs().list(¶ms).await;
}
{
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");
let _ = DocApi::new(invoker).cross_refs().rebuild(¶ms).await;
}
{
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");
let _ = DocApi::new(invoker).cross_refs().remove(¶ms).await;
}
{
let params: DocCustomXmlPartsCreateBoundParams = serde_json::from_str("{\"content\":\"\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.custom_xml()
.parts()
.create(¶ms)
.await;
}
{
let params: DocCustomXmlPartsGetBoundParams =
serde_json::from_str("{\"target\":{\"id\":\"\"}}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).custom_xml().parts().get(¶ms).await;
}
{
let params: DocCustomXmlPartsListBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.custom_xml()
.parts()
.list(¶ms)
.await;
}
{
let params: DocCustomXmlPartsPatchBoundParams =
serde_json::from_str("{\"target\":{\"id\":\"\"}}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.custom_xml()
.parts()
.patch(¶ms)
.await;
}
{
let params: DocCustomXmlPartsRemoveBoundParams =
serde_json::from_str("{\"target\":{\"id\":\"\"}}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.custom_xml()
.parts()
.remove(¶ms)
.await;
}
{
let params: DocDeleteBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).delete(¶ms).await;
}
{
let params: DocDescribeParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = ClientApi::new(invoker).describe(¶ms).await;
}
{
let params: DocDescribeCommandParams = serde_json::from_str("{\"operationId\":\"\"}")
.expect("generated inhabited parameter fixture");
let _ = ClientApi::new(invoker).describe_command(¶ms).await;
}
{
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");
let _ = DocApi::new(invoker).diff().apply(¶ms).await;
}
{
let params: DocDiffCaptureBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).diff().capture(¶ms).await;
}
{
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");
let _ = DocApi::new(invoker).diff().compare(¶ms).await;
}
{
let params: DocDiscoverParams = serde_json::from_str("{\"query\":\"\"}")
.expect("generated inhabited parameter fixture");
let _ = InternalApi::new(invoker).discover(¶ms).await;
}
{
let params: DocExecuteCodeBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).execute_code(¶ms).await;
}
{
let params: DocExportToDocxBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).export().to_docx(¶ms).await;
}
{
let params: DocExtractBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).extract(¶ms).await;
}
{
let params: DocFieldsGetBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"field\",\"blockId\":\"\",\"occurrenceIndex\":0}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).fields().get(¶ms).await;
}
{
let params: DocFieldsInsertBoundParams = serde_json::from_str(
"{\"mode\":\"raw\",\"at\":{\"kind\":\"text\",\"segments\":[]},\"instruction\":\"\"}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).fields().insert(¶ms).await;
}
{
let params: DocFieldsListBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).fields().list(¶ms).await;
}
{
let params: DocFieldsRebuildBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"field\",\"blockId\":\"\",\"occurrenceIndex\":0}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).fields().rebuild(¶ms).await;
}
{
let params:DocFieldsRemoveBoundParams=serde_json::from_str("{\"mode\":\"raw\",\"target\":{\"kind\":\"field\",\"blockId\":\"\",\"occurrenceIndex\":0}}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).fields().remove(¶ms).await;
}
{
let params: DocFindBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).find(¶ms).await;
}
{
let params: DocFootnotesConfigureBoundParams =
serde_json::from_str("{\"type\":\"footnote\",\"scope\":{\"kind\":\"document\"}}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).footnotes().configure(¶ms).await;
}
{
let params: DocFootnotesGetBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"entity\",\"entityType\":\"footnote\",\"noteId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).footnotes().get(¶ms).await;
}
{
let params: DocFootnotesInsertBoundParams = serde_json::from_str("{\"type\":\"footnote\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).footnotes().insert(¶ms).await;
}
{
let params: DocFootnotesListBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).footnotes().list(¶ms).await;
}
{
let params: DocFootnotesRemoveBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"entity\",\"entityType\":\"footnote\",\"noteId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).footnotes().remove(¶ms).await;
}
{
let params:DocFootnotesUpdateBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"entity\",\"entityType\":\"footnote\",\"noteId\":\"\"},\"patch\":{\"content\":\"\"}}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).footnotes().update(¶ms).await;
}
{
let params: DocFormatApplyBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().apply(¶ms).await;
}
{
let params: DocFormatBCsBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().b_cs(¶ms).await;
}
{
let params: DocFormatBoldBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().bold(¶ms).await;
}
{
let params: DocFormatBorderBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().border(¶ms).await;
}
{
let params: DocFormatCapsBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().caps(¶ms).await;
}
{
let params: DocFormatCharScaleBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().char_scale(¶ms).await;
}
{
let params: DocFormatColorBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().color(¶ms).await;
}
{
let params: DocFormatContextualAlternatesBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.format()
.contextual_alternates(¶ms)
.await;
}
{
let params: DocFormatCsBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().cs(¶ms).await;
}
{
let params: DocFormatDstrikeBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().dstrike(¶ms).await;
}
{
let params: DocFormatEastAsianLayoutBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.format()
.east_asian_layout(¶ms)
.await;
}
{
let params: DocFormatEmBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().em(¶ms).await;
}
{
let params: DocFormatEmbossBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().emboss(¶ms).await;
}
{
let params: DocFormatFitTextBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().fit_text(¶ms).await;
}
{
let params: DocFormatFontFamilyBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().font_family(¶ms).await;
}
{
let params: DocFormatFontSizeBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().font_size(¶ms).await;
}
{
let params: DocFormatFontSizeCsBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().font_size_cs(¶ms).await;
}
{
let params: DocFormatHighlightBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().highlight(¶ms).await;
}
{
let params: DocFormatICsBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().i_cs(¶ms).await;
}
{
let params: DocFormatImprintBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().imprint(¶ms).await;
}
{
let params: DocFormatItalicBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().italic(¶ms).await;
}
{
let params: DocFormatKerningBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().kerning(¶ms).await;
}
{
let params: DocFormatLangBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().lang(¶ms).await;
}
{
let params: DocFormatLetterSpacingBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().letter_spacing(¶ms).await;
}
{
let params: DocFormatLigaturesBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().ligatures(¶ms).await;
}
{
let params: DocFormatNumFormBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().num_form(¶ms).await;
}
{
let params: DocFormatNumSpacingBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().num_spacing(¶ms).await;
}
{
let params: DocFormatOMathBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().o_math(¶ms).await;
}
{
let params: DocFormatOutlineBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().outline(¶ms).await;
}
{
let params: DocFormatParagraphClearAlignmentBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.format()
.paragraph()
.clear_alignment(¶ms)
.await;
}
{
let params: DocFormatParagraphClearAllTabStopsBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.format()
.paragraph()
.clear_all_tab_stops(¶ms)
.await;
}
{
let params: DocFormatParagraphClearBorderBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.format()
.paragraph()
.clear_border(¶ms)
.await;
}
{
let params: DocFormatParagraphClearDirectionBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.format()
.paragraph()
.clear_direction(¶ms)
.await;
}
{
let params: DocFormatParagraphClearIndentationBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.format()
.paragraph()
.clear_indentation(¶ms)
.await;
}
{
let params: DocFormatParagraphClearShadingBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.format()
.paragraph()
.clear_shading(¶ms)
.await;
}
{
let params: DocFormatParagraphClearSpacingBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.format()
.paragraph()
.clear_spacing(¶ms)
.await;
}
{
let params: DocFormatParagraphClearTabStopBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.format()
.paragraph()
.clear_tab_stop(¶ms)
.await;
}
{
let params: DocFormatParagraphResetDirectFormattingBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.format()
.paragraph()
.reset_direct_formatting(¶ms)
.await;
}
{
let params: DocFormatParagraphSetAlignmentBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.format()
.paragraph()
.set_alignment(¶ms)
.await;
}
{
let params: DocFormatParagraphSetBorderBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.format()
.paragraph()
.set_border(¶ms)
.await;
}
{
let params: DocFormatParagraphSetDirectionBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.format()
.paragraph()
.set_direction(¶ms)
.await;
}
{
let params: DocFormatParagraphSetFlowOptionsBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.format()
.paragraph()
.set_flow_options(¶ms)
.await;
}
{
let params: DocFormatParagraphSetIndentationBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.format()
.paragraph()
.set_indentation(¶ms)
.await;
}
{
let params: DocFormatParagraphSetKeepOptionsBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.format()
.paragraph()
.set_keep_options(¶ms)
.await;
}
{
let params: DocFormatParagraphSetMarkRunPropsBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.format()
.paragraph()
.set_mark_run_props(¶ms)
.await;
}
{
let params: DocFormatParagraphSetNumberingBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.format()
.paragraph()
.set_numbering(¶ms)
.await;
}
{
let params: DocFormatParagraphSetOutlineLevelBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.format()
.paragraph()
.set_outline_level(¶ms)
.await;
}
{
let params: DocFormatParagraphSetShadingBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.format()
.paragraph()
.set_shading(¶ms)
.await;
}
{
let params: DocFormatParagraphSetSpacingBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.format()
.paragraph()
.set_spacing(¶ms)
.await;
}
{
let params: DocFormatParagraphSetTabStopBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.format()
.paragraph()
.set_tab_stop(¶ms)
.await;
}
{
let params: DocFormatPositionBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().position(¶ms).await;
}
{
let params: DocFormatRFontsBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().r_fonts(¶ms).await;
}
{
let params: DocFormatRStyleBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().r_style(¶ms).await;
}
{
let params: DocFormatRtlBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().rtl(¶ms).await;
}
{
let params: DocFormatShadingBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().shading(¶ms).await;
}
{
let params: DocFormatShadowBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().shadow(¶ms).await;
}
{
let params: DocFormatSmallCapsBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().small_caps(¶ms).await;
}
{
let params: DocFormatSnapToGridBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().snap_to_grid(¶ms).await;
}
{
let params: DocFormatSpecVanishBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().spec_vanish(¶ms).await;
}
{
let params: DocFormatStrikeBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().strike(¶ms).await;
}
{
let params: DocFormatStylisticSetsBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().stylistic_sets(¶ms).await;
}
{
let params: DocFormatUnderlineBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().underline(¶ms).await;
}
{
let params: DocFormatVanishBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().vanish(¶ms).await;
}
{
let params: DocFormatVertAlignBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().vert_align(¶ms).await;
}
{
let params: DocFormatWebHiddenBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format().web_hidden(¶ms).await;
}
{
let params: DocFormatRangeBoundParams = serde_json::from_str("{\"properties\":{}}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).format_range(¶ms).await;
}
{
let params: DocGetBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).get(¶ms).await;
}
{
let params: DocGetHtmlBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).get_html(¶ms).await;
}
{
let params: DocGetMarkdownBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).get_markdown(¶ms).await;
}
{
let params: DocGetNodeBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).get_node(¶ms).await;
}
{
let params: DocGetNodeByIdBoundParams =
serde_json::from_str("{\"id\":\"\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).get_node_by_id(¶ms).await;
}
{
let params: DocGetTextBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).get_text(¶ms).await;
}
{
let params:DocHeaderFootersGetBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"headerFooterSlot\",\"section\":{\"kind\":\"section\",\"sectionId\":\"\"},\"headerFooterKind\":\"header\",\"variant\":\"default\"}}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).header_footers().get(¶ms).await;
}
{
let params: DocHeaderFootersListBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).header_footers().list(¶ms).await;
}
{
let params: DocHeaderFootersPageNumbersGetBoundParams =
serde_json::from_str("{\"section\":{\"kind\":\"section\",\"sectionId\":\"\"}}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.header_footers()
.page_numbers()
.get(¶ms)
.await;
}
{
let params: DocHeaderFootersPageNumbersInsertBoundParams = serde_json::from_str(
"{\"section\":{\"kind\":\"section\",\"sectionId\":\"\"},\"kind\":\"header\"}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.header_footers()
.page_numbers()
.insert(¶ms)
.await;
}
{
let params: DocHeaderFootersPageNumbersRemoveBoundParams =
serde_json::from_str("{\"section\":{\"kind\":\"section\",\"sectionId\":\"\"}}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.header_footers()
.page_numbers()
.remove(¶ms)
.await;
}
{
let params: DocHeaderFootersPageNumbersSetBoundParams = serde_json::from_str(
"{\"section\":{\"kind\":\"section\",\"sectionId\":\"\"},\"kind\":\"header\"}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.header_footers()
.page_numbers()
.set(¶ms)
.await;
}
{
let params: DocHeaderFootersPartsCreateBoundParams =
serde_json::from_str("{\"kind\":\"header\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.header_footers()
.parts()
.create(¶ms)
.await;
}
{
let params: DocHeaderFootersPartsDeleteBoundParams =
serde_json::from_str("{\"target\":{\"kind\":\"headerFooterPart\",\"refId\":\"\"}}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.header_footers()
.parts()
.delete(¶ms)
.await;
}
{
let params: DocHeaderFootersPartsListBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.header_footers()
.parts()
.list(¶ms)
.await;
}
{
let params:DocHeaderFootersRefsClearBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"headerFooterSlot\",\"section\":{\"kind\":\"section\",\"sectionId\":\"\"},\"headerFooterKind\":\"header\",\"variant\":\"default\"}}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.header_footers()
.refs()
.clear(¶ms)
.await;
}
{
let params:DocHeaderFootersRefsSetBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"headerFooterSlot\",\"section\":{\"kind\":\"section\",\"sectionId\":\"\"},\"headerFooterKind\":\"header\",\"variant\":\"default\"},\"refId\":\"\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.header_footers()
.refs()
.set(¶ms)
.await;
}
{
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");
let _ = DocApi::new(invoker)
.header_footers()
.refs()
.set_linked_to_previous(¶ms)
.await;
}
{
let params:DocHeaderFootersResolveBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"headerFooterSlot\",\"section\":{\"kind\":\"section\",\"sectionId\":\"\"},\"headerFooterKind\":\"header\",\"variant\":\"default\"}}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).header_footers().resolve(¶ms).await;
}
{
let params: DocHistoryGetBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).history().get(¶ms).await;
}
{
let params: DocHistoryRedoBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).history().redo(¶ms).await;
}
{
let params: DocHistoryUndoBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).history().undo(¶ms).await;
}
{
let params: DocHtmlToFragmentBoundParams =
serde_json::from_str("{\"html\":\"\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).html_to_fragment(¶ms).await;
}
{
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");
let _ = DocApi::new(invoker).hyperlinks().get(¶ms).await;
}
{
let params: DocHyperlinksInsertBoundParams =
serde_json::from_str("{\"text\":\"\",\"link\":{\"destination\":{}}}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).hyperlinks().insert(¶ms).await;
}
{
let params: DocHyperlinksListBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).hyperlinks().list(¶ms).await;
}
{
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");
let _ = DocApi::new(invoker).hyperlinks().patch(¶ms).await;
}
{
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");
let _ = DocApi::new(invoker).hyperlinks().remove(¶ms).await;
}
{
let params:DocHyperlinksWrapBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"text\",\"blockId\":\"\",\"range\":{\"start\":0,\"end\":0}},\"link\":{\"destination\":{}}}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).hyperlinks().wrap(¶ms).await;
}
{
let params: DocImagesConvertToFloatingBoundParams =
serde_json::from_str("{\"imageId\":\"\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.images()
.convert_to_floating(¶ms)
.await;
}
{
let params: DocImagesConvertToInlineBoundParams =
serde_json::from_str("{\"imageId\":\"\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.images()
.convert_to_inline(¶ms)
.await;
}
{
let params: DocImagesCropBoundParams =
serde_json::from_str("{\"imageId\":\"\",\"crop\":{}}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).images().crop(¶ms).await;
}
{
let params: DocImagesDeleteBoundParams = serde_json::from_str("{\"imageId\":\"\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).images().delete(¶ms).await;
}
{
let params: DocImagesFlipBoundParams = serde_json::from_str("{\"imageId\":\"\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).images().flip(¶ms).await;
}
{
let params: DocImagesGetBoundParams = serde_json::from_str("{\"imageId\":\"\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).images().get(¶ms).await;
}
{
let params: DocImagesInsertCaptionBoundParams =
serde_json::from_str("{\"imageId\":\"\",\"text\":\"\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).images().insert_caption(¶ms).await;
}
{
let params: DocImagesListBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).images().list(¶ms).await;
}
{
let params: DocImagesMoveBoundParams =
serde_json::from_str("{\"imageId\":\"\",\"to\":{\"kind\":\"documentStart\"}}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).images().move_(¶ms).await;
}
{
let params: DocImagesRemoveCaptionBoundParams = serde_json::from_str("{\"imageId\":\"\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).images().remove_caption(¶ms).await;
}
{
let params: DocImagesReplaceSourceBoundParams =
serde_json::from_str("{\"imageId\":\"\",\"src\":\"\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).images().replace_source(¶ms).await;
}
{
let params: DocImagesResetCropBoundParams = serde_json::from_str("{\"imageId\":\"\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).images().reset_crop(¶ms).await;
}
{
let params: DocImagesRotateBoundParams =
serde_json::from_str("{\"imageId\":\"\",\"angle\":0}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).images().rotate(¶ms).await;
}
{
let params: DocImagesScaleBoundParams =
serde_json::from_str("{\"imageId\":\"\",\"factor\":0}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).images().scale(¶ms).await;
}
{
let params: DocImagesSetAltTextBoundParams =
serde_json::from_str("{\"imageId\":\"\",\"description\":\"\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).images().set_alt_text(¶ms).await;
}
{
let params: DocImagesSetAnchorOptionsBoundParams =
serde_json::from_str("{\"imageId\":\"\",\"options\":{}}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.images()
.set_anchor_options(¶ms)
.await;
}
{
let params: DocImagesSetDecorativeBoundParams =
serde_json::from_str("{\"imageId\":\"\",\"decorative\":false}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).images().set_decorative(¶ms).await;
}
{
let params: DocImagesSetHyperlinkBoundParams =
serde_json::from_str("{\"imageId\":\"\",\"url\":null}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).images().set_hyperlink(¶ms).await;
}
{
let params: DocImagesSetLockAspectRatioBoundParams =
serde_json::from_str("{\"imageId\":\"\",\"locked\":false}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.images()
.set_lock_aspect_ratio(¶ms)
.await;
}
{
let params: DocImagesSetNameBoundParams =
serde_json::from_str("{\"imageId\":\"\",\"name\":\"\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).images().set_name(¶ms).await;
}
{
let params: DocImagesSetPositionBoundParams =
serde_json::from_str("{\"imageId\":\"\",\"position\":{}}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).images().set_position(¶ms).await;
}
{
let params: DocImagesSetSizeBoundParams =
serde_json::from_str("{\"imageId\":\"\",\"size\":{\"width\":0,\"height\":0}}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).images().set_size(¶ms).await;
}
{
let params: DocImagesSetWrapDistancesBoundParams =
serde_json::from_str("{\"imageId\":\"\",\"distances\":{}}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.images()
.set_wrap_distances(¶ms)
.await;
}
{
let params: DocImagesSetWrapSideBoundParams =
serde_json::from_str("{\"imageId\":\"\",\"side\":\"bothSides\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).images().set_wrap_side(¶ms).await;
}
{
let params: DocImagesSetWrapTypeBoundParams =
serde_json::from_str("{\"imageId\":\"\",\"type\":\"None\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).images().set_wrap_type(¶ms).await;
}
{
let params: DocImagesSetZOrderBoundParams =
serde_json::from_str("{\"imageId\":\"\",\"zOrder\":{\"relativeHeight\":0}}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).images().set_z_order(¶ms).await;
}
{
let params: DocImagesUpdateCaptionBoundParams =
serde_json::from_str("{\"imageId\":\"\",\"text\":\"\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).images().update_caption(¶ms).await;
}
{
let params: DocIndexConfigureBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"index\",\"nodeId\":\"\"},\"patch\":{}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).index().configure(¶ms).await;
}
{
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");
let _ = DocApi::new(invoker).index().entries().get(¶ms).await;
}
{
let params: DocIndexEntriesInsertBoundParams = serde_json::from_str(
"{\"at\":{\"kind\":\"text\",\"segments\":[]},\"entry\":{\"text\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).index().entries().insert(¶ms).await;
}
{
let params: DocIndexEntriesListBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).index().entries().list(¶ms).await;
}
{
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");
let _ = DocApi::new(invoker).index().entries().remove(¶ms).await;
}
{
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");
let _ = DocApi::new(invoker).index().entries().update(¶ms).await;
}
{
let params: DocIndexGetBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"index\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).index().get(¶ms).await;
}
{
let params: DocIndexInsertBoundParams =
serde_json::from_str("{\"at\":{\"kind\":\"documentStart\"}}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).index().insert(¶ms).await;
}
{
let params: DocIndexListBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).index().list(¶ms).await;
}
{
let params: DocIndexRebuildBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"index\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).index().rebuild(¶ms).await;
}
{
let params: DocIndexRemoveBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"index\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).index().remove(¶ms).await;
}
{
let params: DocInfoBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).info(¶ms).await;
}
{
let params: DocInsertBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).insert(¶ms).await;
}
{
let params: DocInsertLineBreakBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).insert_line_break(¶ms).await;
}
{
let params: DocInsertTabBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).insert_tab(¶ms).await;
}
{
let params:DocListsApplyBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"paragraph\",\"nodeId\":\"\"},\"seed\":\"bullet\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).lists().apply(¶ms).await;
}
{
let params: DocListsApplyPresetBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).lists().apply_preset(¶ms).await;
}
{
let params:DocListsApplyStyleBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"listItem\",\"nodeId\":\"\"},\"style\":{\"version\":1,\"levels\":[]}}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).lists().apply_style(¶ms).await;
}
{
let params: DocListsApplyTemplateBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).lists().apply_template(¶ms).await;
}
{
let params: DocListsAttachBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).lists().attach(¶ms).await;
}
{
let params: DocListsCanContinuePreviousBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.lists()
.can_continue_previous(¶ms)
.await;
}
{
let params: DocListsCanJoinBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).lists().can_join(¶ms).await;
}
{
let params: DocListsCaptureTemplateBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).lists().capture_template(¶ms).await;
}
{
let params: DocListsClearLevelOverridesBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.lists()
.clear_level_overrides(¶ms)
.await;
}
{
let params: DocListsContinueBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"paragraph\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).lists().continue_(¶ms).await;
}
{
let params: DocListsContinuePreviousBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.lists()
.continue_previous(¶ms)
.await;
}
{
let params: DocListsConvertToTextBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).lists().convert_to_text(¶ms).await;
}
{
let params: DocListsCreateBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).lists().create(¶ms).await;
}
{
let params: DocListsDeleteBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"listItem\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).lists().delete(¶ms).await;
}
{
let params: DocListsDetachBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).lists().detach(¶ms).await;
}
{
let params: DocListsGetBoundParams = serde_json::from_str(
"{\"address\":{\"kind\":\"block\",\"nodeType\":\"listItem\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).lists().get(¶ms).await;
}
{
let params: DocListsGetStateBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"paragraph\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).lists().get_state(¶ms).await;
}
{
let params: DocListsGetStyleBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"listItem\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).lists().get_style(¶ms).await;
}
{
let params: DocListsIndentBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).lists().indent(¶ms).await;
}
{
let params: DocListsInsertBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).lists().insert(¶ms).await;
}
{
let params: DocListsJoinBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).lists().join(¶ms).await;
}
{
let params: DocListsListBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).lists().list(¶ms).await;
}
{
let params:DocListsMergeBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"listItem\",\"nodeId\":\"\"},\"direction\":\"withPrevious\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).lists().merge(¶ms).await;
}
{
let params: DocListsOutdentBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).lists().outdent(¶ms).await;
}
{
let params: DocListsRemoveBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"paragraph\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).lists().remove(¶ms).await;
}
{
let params: DocListsRestartBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"paragraph\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).lists().restart(¶ms).await;
}
{
let params:DocListsRestartAtBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"listItem\",\"nodeId\":\"\"},\"startAt\":0}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).lists().restart_at(¶ms).await;
}
{
let params: DocListsSeparateBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).lists().separate(¶ms).await;
}
{
let params: DocListsSetLevelBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).lists().set_level(¶ms).await;
}
{
let params: DocListsSetLevelAlignmentBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.lists()
.set_level_alignment(¶ms)
.await;
}
{
let params: DocListsSetLevelBulletBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).lists().set_level_bullet(¶ms).await;
}
{
let params: DocListsSetLevelIndentsBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.lists()
.set_level_indents(¶ms)
.await;
}
{
let params:DocListsSetLevelLayoutBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"listItem\",\"nodeId\":\"\"},\"level\":0,\"layout\":{}}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).lists().set_level_layout(¶ms).await;
}
{
let params: DocListsSetLevelMarkerFontBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.lists()
.set_level_marker_font(¶ms)
.await;
}
{
let params: DocListsSetLevelNumberingBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.lists()
.set_level_numbering(¶ms)
.await;
}
{
let params:DocListsSetLevelNumberStyleBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"listItem\",\"nodeId\":\"\"},\"level\":0,\"numberStyle\":\"\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.lists()
.set_level_number_style(¶ms)
.await;
}
{
let params: DocListsSetLevelPictureBulletBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.lists()
.set_level_picture_bullet(¶ms)
.await;
}
{
let params: DocListsSetLevelRestartBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.lists()
.set_level_restart(¶ms)
.await;
}
{
let params:DocListsSetLevelStartBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"listItem\",\"nodeId\":\"\"},\"level\":0,\"startAt\":0}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).lists().set_level_start(¶ms).await;
}
{
let params:DocListsSetLevelTextBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"listItem\",\"nodeId\":\"\"},\"level\":0,\"text\":\"\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).lists().set_level_text(¶ms).await;
}
{
let params: DocListsSetLevelTrailingCharacterBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.lists()
.set_level_trailing_character(¶ms)
.await;
}
{
let params:DocListsSetTypeBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"listItem\",\"nodeId\":\"\"},\"kind\":\"ordered\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).lists().set_type(¶ms).await;
}
{
let params: DocListsSetValueBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).lists().set_value(¶ms).await;
}
{
let params: DocListsSplitBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"listItem\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).lists().split(¶ms).await;
}
{
let params: DocMarkdownToFragmentBoundParams = serde_json::from_str("{\"markdown\":\"\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).markdown_to_fragment(¶ms).await;
}
{
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");
let _ = DocApi::new(invoker).metadata().attach(¶ms).await;
}
{
let params: DocMetadataGetBoundParams =
serde_json::from_str("{\"id\":\"\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).metadata().get(¶ms).await;
}
{
let params: DocMetadataListBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).metadata().list(¶ms).await;
}
{
let params: DocMetadataRemoveBoundParams =
serde_json::from_str("{\"id\":\"\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).metadata().remove(¶ms).await;
}
{
let params: DocMetadataResolveBoundParams =
serde_json::from_str("{\"id\":\"\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).metadata().resolve(¶ms).await;
}
{
let params: DocMetadataUpdateBoundParams =
serde_json::from_str("{\"id\":\"\",\"payload\":null}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).metadata().update(¶ms).await;
}
{
let params: DocMutationsApplyBoundParams =
serde_json::from_str("{\"atomic\":false,\"steps\":[]}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).mutations().apply(¶ms).await;
}
{
let params: DocMutationsPreviewBoundParams =
serde_json::from_str("{\"atomic\":false,\"changeMode\":\"direct\",\"steps\":[]}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).mutations().preview(¶ms).await;
}
{
let params: DocOpenParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = ClientApi::new(invoker).open(¶ms).await;
}
{
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");
let _ = DocApi::new(invoker)
.permission_ranges()
.create(¶ms)
.await;
}
{
let params: DocPermissionRangesGetBoundParams =
serde_json::from_str("{\"id\":\"\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).permission_ranges().get(¶ms).await;
}
{
let params: DocPermissionRangesListBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).permission_ranges().list(¶ms).await;
}
{
let params: DocPermissionRangesRemoveBoundParams =
serde_json::from_str("{\"id\":\"\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.permission_ranges()
.remove(¶ms)
.await;
}
{
let params: DocPermissionRangesUpdatePrincipalBoundParams =
serde_json::from_str("{\"id\":\"\",\"principal\":{\"kind\":\"everyone\"}}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.permission_ranges()
.update_principal(¶ms)
.await;
}
{
let params: DocPlanExecuteBoundParams = serde_json::from_str("{\"entries\":[]}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).plan().execute(¶ms).await;
}
{
let params: DocPresetDispatchBoundParams = serde_json::from_str("{\"toolName\":\"\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).preset().dispatch(¶ms).await;
}
{
let params: DocPresetGetCatalogBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).preset().get_catalog(¶ms).await;
}
{
let params: DocPresetGetMcpPromptBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).preset().get_mcp_prompt(¶ms).await;
}
{
let params: DocPresetGetSystemPromptBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.preset()
.get_system_prompt(¶ms)
.await;
}
{
let params: DocPresetGetToolsBoundParams =
serde_json::from_str("{\"provider\":\"openai\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).preset().get_tools(¶ms).await;
}
{
let params: DocPresetListBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).preset().list(¶ms).await;
}
{
let params: DocProjectHtmlBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).project_html(¶ms).await;
}
{
let params: DocProjectMarkdownBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).project_markdown(¶ms).await;
}
{
let params: DocProtectionClearEditingRestrictionBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.protection()
.clear_editing_restriction(¶ms)
.await;
}
{
let params: DocProtectionGetBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).protection().get(¶ms).await;
}
{
let params: DocProtectionSetEditingRestrictionBoundParams =
serde_json::from_str("{\"mode\":\"readOnly\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.protection()
.set_editing_restriction(¶ms)
.await;
}
{
let params: DocQueryMatchBoundParams =
serde_json::from_str("{\"select\":{\"type\":\"text\",\"pattern\":\"\"}}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).query().match_(¶ms).await;
}
{
let params:DocRangesResolveBoundParams=serde_json::from_str("{\"start\":{\"kind\":\"document\",\"edge\":\"start\"},\"end\":{\"kind\":\"document\",\"edge\":\"start\"}}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).ranges().resolve(¶ms).await;
}
{
let params: DocReplaceBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).replace(¶ms).await;
}
{
let params: DocSaveBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).save(¶ms).await;
}
{
let params:DocSectionsClearHeaderFooterRefBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"section\",\"sectionId\":\"\"},\"kind\":\"header\",\"variant\":\"default\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.sections()
.clear_header_footer_ref(¶ms)
.await;
}
{
let params: DocSectionsClearPageBordersBoundParams =
serde_json::from_str("{\"target\":{\"kind\":\"section\",\"sectionId\":\"\"}}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.sections()
.clear_page_borders(¶ms)
.await;
}
{
let params: DocSectionsGetBoundParams =
serde_json::from_str("{\"address\":{\"kind\":\"section\",\"sectionId\":\"\"}}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).sections().get(¶ms).await;
}
{
let params: DocSectionsListBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).sections().list(¶ms).await;
}
{
let params: DocSectionsSetBreakTypeBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"section\",\"sectionId\":\"\"},\"breakType\":\"continuous\"}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.sections()
.set_break_type(¶ms)
.await;
}
{
let params: DocSectionsSetColumnsBoundParams =
serde_json::from_str("{\"target\":{\"kind\":\"section\",\"sectionId\":\"\"}}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).sections().set_columns(¶ms).await;
}
{
let params: DocSectionsSetHeaderFooterMarginsBoundParams =
serde_json::from_str("{\"target\":{\"kind\":\"section\",\"sectionId\":\"\"}}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.sections()
.set_header_footer_margins(¶ms)
.await;
}
{
let params:DocSectionsSetHeaderFooterRefBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"section\",\"sectionId\":\"\"},\"kind\":\"header\",\"variant\":\"default\",\"refId\":\"\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.sections()
.set_header_footer_ref(¶ms)
.await;
}
{
let params: DocSectionsSetLineNumberingBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"section\",\"sectionId\":\"\"},\"enabled\":false}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.sections()
.set_line_numbering(¶ms)
.await;
}
{
let params:DocSectionsSetLinkToPreviousBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"section\",\"sectionId\":\"\"},\"kind\":\"header\",\"variant\":\"default\",\"linked\":false}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.sections()
.set_link_to_previous(¶ms)
.await;
}
{
let params: DocSectionsSetOddEvenHeadersFootersBoundParams =
serde_json::from_str("{\"enabled\":false}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.sections()
.set_odd_even_headers_footers(¶ms)
.await;
}
{
let params: DocSectionsSetPageBordersBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"section\",\"sectionId\":\"\"},\"borders\":null}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.sections()
.set_page_borders(¶ms)
.await;
}
{
let params: DocSectionsSetPageMarginsBoundParams =
serde_json::from_str("{\"target\":{\"kind\":\"section\",\"sectionId\":\"\"}}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.sections()
.set_page_margins(¶ms)
.await;
}
{
let params: DocSectionsSetPageNumberingBoundParams =
serde_json::from_str("{\"target\":{\"kind\":\"section\",\"sectionId\":\"\"}}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.sections()
.set_page_numbering(¶ms)
.await;
}
{
let params: DocSectionsSetPageSetupBoundParams =
serde_json::from_str("{\"target\":{\"kind\":\"section\",\"sectionId\":\"\"}}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.sections()
.set_page_setup(¶ms)
.await;
}
{
let params: DocSectionsSetSectionDirectionBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"section\",\"sectionId\":\"\"},\"direction\":\"ltr\"}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.sections()
.set_section_direction(¶ms)
.await;
}
{
let params: DocSectionsSetTitlePageBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"section\",\"sectionId\":\"\"},\"enabled\":false}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.sections()
.set_title_page(¶ms)
.await;
}
{
let params: DocSectionsSetVerticalAlignBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"section\",\"sectionId\":\"\"},\"value\":\"top\"}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.sections()
.set_vertical_align(¶ms)
.await;
}
{
let params: DocSelectionCurrentBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).selection().current(¶ms).await;
}
{
let params: DocSelectionExtractOoxmlBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.selection()
.extract_ooxml(¶ms)
.await;
}
{
let params: DocSelectionReleaseSnapshotBoundParams =
serde_json::from_str("{\"snapshotId\":\"\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.selection()
.release_snapshot(¶ms)
.await;
}
{
let params: DocSessionCloseParams = serde_json::from_str("{\"sessionId\":\"\"}")
.expect("generated inhabited parameter fixture");
let _ = InternalApi::new(invoker).session().close(¶ms).await;
}
{
let params: DocSessionListParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = InternalApi::new(invoker).session().list(¶ms).await;
}
{
let params: DocSessionSaveParams = serde_json::from_str("{\"sessionId\":\"\"}")
.expect("generated inhabited parameter fixture");
let _ = InternalApi::new(invoker).session().save(¶ms).await;
}
{
let params: DocSessionSetDefaultParams = serde_json::from_str("{\"sessionId\":\"\"}")
.expect("generated inhabited parameter fixture");
let _ = InternalApi::new(invoker)
.session()
.set_default(¶ms)
.await;
}
{
let params: DocStatusParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = InternalApi::new(invoker).status(¶ms).await;
}
{
let params: DocStylesApplyBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).styles().apply(¶ms).await;
}
{
let params: DocStylesCreateBoundParams =
serde_json::from_str("{\"id\":\"\",\"name\":\"\",\"type\":\"paragraph\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).styles().create(¶ms).await;
}
{
let params: DocStylesGetCatalogBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).styles().get_catalog(¶ms).await;
}
{
let params: DocStylesGetThemeBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).styles().get_theme(¶ms).await;
}
{
let params: DocStylesParagraphClearStyleBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"paragraph\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.styles()
.paragraph()
.clear_style(¶ms)
.await;
}
{
let params: DocStylesParagraphSetStyleBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"paragraph\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.styles()
.paragraph()
.set_style(¶ms)
.await;
}
{
let params:DocStylesParagraphSetStyleRefBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"paragraph\",\"nodeId\":\"\"},\"styleId\":\"\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.styles()
.paragraph()
.set_style_ref(¶ms)
.await;
}
{
let params: DocTablesApplyBorderPresetBoundParams =
serde_json::from_str("{\"preset\":\"box\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.tables()
.apply_border_preset(¶ms)
.await;
}
{
let params: DocTablesApplyPresetBoundParams = serde_json::from_str("{\"preset\":\"grid\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().apply_preset(¶ms).await;
}
{
let params: DocTablesApplyStyleBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().apply_style(¶ms).await;
}
{
let params: DocTablesClearBorderBoundParams = serde_json::from_str("{\"edge\":\"top\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().clear_border(¶ms).await;
}
{
let params: DocTablesClearCellSpacingBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.tables()
.clear_cell_spacing(¶ms)
.await;
}
{
let params: DocTablesClearContentsBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().clear_contents(¶ms).await;
}
{
let params: DocTablesClearDefaultStyleBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.tables()
.clear_default_style(¶ms)
.await;
}
{
let params: DocTablesClearShadingBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().clear_shading(¶ms).await;
}
{
let params: DocTablesClearStyleBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().clear_style(¶ms).await;
}
{
let params: DocTablesConvertFromTextBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.tables()
.convert_from_text(¶ms)
.await;
}
{
let params: DocTablesConvertToTextBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().convert_to_text(¶ms).await;
}
{
let params: DocTablesDeleteBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().delete(¶ms).await;
}
{
let params: DocTablesDeleteCellBoundParams =
serde_json::from_str("{\"mode\":\"shiftLeft\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().delete_cell(¶ms).await;
}
{
let params: DocTablesDeleteColumnBoundParams = serde_json::from_str("{\"columnIndex\":0}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().delete_column(¶ms).await;
}
{
let params: DocTablesDeleteRowBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().delete_row(¶ms).await;
}
{
let params: DocTablesDistributeColumnsBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.tables()
.distribute_columns(¶ms)
.await;
}
{
let params: DocTablesDistributeRowsBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().distribute_rows(¶ms).await;
}
{
let params: DocTablesGetBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().get(¶ms).await;
}
{
let params: DocTablesGetCellsBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().get_cells(¶ms).await;
}
{
let params: DocTablesGetPropertiesBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().get_properties(¶ms).await;
}
{
let params: DocTablesGetStylesBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().get_styles(¶ms).await;
}
{
let params: DocTablesInsertCellBoundParams =
serde_json::from_str("{\"mode\":\"shiftRight\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().insert_cell(¶ms).await;
}
{
let params: DocTablesInsertColumnBoundParams =
serde_json::from_str("{\"position\":\"left\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().insert_column(¶ms).await;
}
{
let params: DocTablesInsertRowBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().insert_row(¶ms).await;
}
{
let params:DocTablesMergeCellsBoundParams=serde_json::from_str("{\"start\":{\"rowIndex\":0,\"columnIndex\":0},\"end\":{\"rowIndex\":0,\"columnIndex\":0}}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().merge_cells(¶ms).await;
}
{
let params: DocTablesMoveBoundParams =
serde_json::from_str("{\"destination\":{\"kind\":\"documentStart\"}}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().move_(¶ms).await;
}
{
let params: DocTablesMoveColumnBoundParams =
serde_json::from_str("{\"columnIndex\":0,\"destination\":{\"kind\":\"first\"}}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().move_column(¶ms).await;
}
{
let params: DocTablesMoveRowBoundParams =
serde_json::from_str("{\"destination\":{\"kind\":\"first\"}}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().move_row(¶ms).await;
}
{
let params: DocTablesSetAltTextBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().set_alt_text(¶ms).await;
}
{
let params: DocTablesSetBorderBoundParams = serde_json::from_str(
"{\"edge\":\"top\",\"lineStyle\":\"\",\"lineWeightPt\":0,\"color\":\"\"}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().set_border(¶ms).await;
}
{
let params: DocTablesSetBordersBoundParams = serde_json::from_str("{\"mode\":\"applyTo\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().set_borders(¶ms).await;
}
{
let params: DocTablesSetCellPaddingBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.tables()
.set_cell_padding(¶ms)
.await;
}
{
let params: DocTablesSetCellPropertiesBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.tables()
.set_cell_properties(¶ms)
.await;
}
{
let params: DocTablesSetCellSpacingBoundParams = serde_json::from_str("{\"spacingPt\":0}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.tables()
.set_cell_spacing(¶ms)
.await;
}
{
let params: DocTablesSetCellTextBoundParams =
serde_json::from_str("{\"text\":\"\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().set_cell_text(¶ms).await;
}
{
let params: DocTablesSetColumnWidthBoundParams =
serde_json::from_str("{\"columnIndex\":0,\"widthPt\":0}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.tables()
.set_column_width(¶ms)
.await;
}
{
let params: DocTablesSetDefaultStyleBoundParams =
serde_json::from_str("{\"styleId\":\"\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.tables()
.set_default_style(¶ms)
.await;
}
{
let params: DocTablesSetLayoutBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().set_layout(¶ms).await;
}
{
let params: DocTablesSetRowHeightBoundParams = serde_json::from_str("{\"heightPt\":0}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().set_row_height(¶ms).await;
}
{
let params: DocTablesSetRowOptionsBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().set_row_options(¶ms).await;
}
{
let params: DocTablesSetShadingBoundParams = serde_json::from_str("{\"color\":\"\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().set_shading(¶ms).await;
}
{
let params: DocTablesSetStyleBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().set_style(¶ms).await;
}
{
let params: DocTablesSetStyleOptionBoundParams =
serde_json::from_str("{\"flag\":\"headerRow\",\"enabled\":false}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.tables()
.set_style_option(¶ms)
.await;
}
{
let params: DocTablesSetTableOptionsBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.tables()
.set_table_options(¶ms)
.await;
}
{
let params: DocTablesSetTablePaddingBoundParams =
serde_json::from_str("{\"topPt\":0,\"rightPt\":0,\"bottomPt\":0,\"leftPt\":0}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker)
.tables()
.set_table_padding(¶ms)
.await;
}
{
let params: DocTablesSortBoundParams =
serde_json::from_str("{\"keys\":[]}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().sort(¶ms).await;
}
{
let params: DocTablesSplitBoundParams = serde_json::from_str("{\"rowIndex\":0}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().split(¶ms).await;
}
{
let params: DocTablesSplitCellBoundParams =
serde_json::from_str("{\"rows\":0,\"columns\":0}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().split_cell(¶ms).await;
}
{
let params: DocTablesUnmergeCellsBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).tables().unmerge_cells(¶ms).await;
}
{
let params: DocTemplatesApplyBoundParams =
serde_json::from_str("{\"source\":{\"kind\":\"path\",\"path\":\"\"}}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).templates().apply(¶ms).await;
}
{
let params:DocTocConfigureBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"block\",\"nodeType\":\"tableOfContents\",\"nodeId\":\"\"},\"patch\":{}}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).toc().configure(¶ms).await;
}
{
let params:DocTocEditEntryBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"inline\",\"nodeType\":\"tableOfContentsEntry\",\"nodeId\":\"\"},\"patch\":{}}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).toc().edit_entry(¶ms).await;
}
{
let params: DocTocGetBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"tableOfContents\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).toc().get(¶ms).await;
}
{
let params:DocTocGetEntryBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"inline\",\"nodeType\":\"tableOfContentsEntry\",\"nodeId\":\"\"}}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).toc().get_entry(¶ms).await;
}
{
let params: DocTocListBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).toc().list(¶ms).await;
}
{
let params: DocTocListEntriesBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).toc().list_entries(¶ms).await;
}
{
let params:DocTocMarkEntryBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"inline-insert\",\"anchor\":{\"nodeType\":\"paragraph\",\"nodeId\":\"\"}},\"text\":\"\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).toc().mark_entry(¶ms).await;
}
{
let params: DocTocRemoveBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"tableOfContents\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).toc().remove(¶ms).await;
}
{
let params:DocTocUnmarkEntryBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"inline\",\"nodeType\":\"tableOfContentsEntry\",\"nodeId\":\"\"}}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).toc().unmark_entry(¶ms).await;
}
{
let params: DocTocUpdateBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"block\",\"nodeType\":\"tableOfContents\",\"nodeId\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).toc().update(¶ms).await;
}
{
let params: DocTrackChangesDecideBoundParams = serde_json::from_str(
"{\"decision\":\"accept\",\"target\":{\"kind\":\"id\",\"id\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).track_changes().decide(¶ms).await;
}
{
let params: DocTrackChangesGetBoundParams =
serde_json::from_str("{\"id\":\"\"}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).track_changes().get(¶ms).await;
}
{
let params: DocTrackChangesListBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).track_changes().list(¶ms).await;
}
{
let params: DocWatermarksApplyBoundParams =
serde_json::from_str("{\"target\":{\"kind\":\"document\"},\"action\":\"insert\"}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).watermarks().apply(¶ms).await;
}
{
let params: DocWatermarksInsertBoundParams = serde_json::from_str(
"{\"target\":{\"kind\":\"document\"},\"watermark\":{\"kind\":\"text\",\"text\":\"\"}}",
)
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).watermarks().insert(¶ms).await;
}
{
let params: DocWatermarksListBoundParams =
serde_json::from_str("{}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).watermarks().list(¶ms).await;
}
{
let params: DocWatermarksRemoveBoundParams =
serde_json::from_str("{\"target\":{\"kind\":\"watermark\",\"watermarkId\":\"\"}}")
.expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).watermarks().remove(¶ms).await;
}
{
let params:DocWatermarksReplaceBoundParams=serde_json::from_str("{\"target\":{\"kind\":\"watermark\",\"watermarkId\":\"\"},\"watermark\":{\"kind\":\"text\",\"text\":\"\"}}").expect("generated inhabited parameter fixture");
let _ = DocApi::new(invoker).watermarks().replace(¶ms).await;
}
}