notebooklm 4.7.0

// @generated by scripts/build-rust-client.mjs from
// deployment/docs/openapi.yaml — do not edit by hand. Run `npm run rust:sync`.
//
// A hand-written client stops at the routes someone remembered. This one is
// the specification, so a new operation reaches a Rust caller on the release
// that ships it.

// Field names mirror the wire, and a description only exists where the
// specification carries one — so the missing-docs lint is allowed here and
// nowhere else in the crate.
#![allow(
    missing_docs,
    clippy::too_many_arguments,
    clippy::doc_markdown,
    clippy::struct_excessive_bools
)]

use serde::{Deserialize, Serialize};

use crate::client::Client;
use crate::error::Result;

/// The root route is not wrapped in the success envelope: it is the server's own banner, and it lists every other route.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ServerInfo {
    #[serde(default)]
    pub name: String,
    #[serde(default)]
    pub version: String,
    #[serde(default)]
    pub docs: String,
    #[serde(default)]
    pub endpoints: serde_json::Value,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct GetHealthData {
    #[serde(default)]
    pub status: String,
    #[serde(default)]
    pub authenticated: bool,
    #[serde(default)]
    pub notebook_url: String,
    #[serde(default)]
    pub active_sessions: i64,
    #[serde(default)]
    pub max_sessions: i64,
    #[serde(default)]
    pub session_timeout: i64,
    #[serde(default)]
    pub total_messages: i64,
    #[serde(default)]
    pub headless: bool,
    #[serde(default)]
    pub auto_login_enabled: bool,
    #[serde(default)]
    pub stealth_enabled: bool,
    #[serde(default)]
    pub troubleshooting_tip: String,
}

/// A UTCP manual, whose shape belongs to the client's own model rather than to this server. Every url is rebased onto the address the request arrived at.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct UtcpManual {
    #[serde(default)]
    pub utcp_version: String,
    #[serde(default)]
    pub manual_version: String,
    #[serde(default)]
    pub tools: Vec<UtcpManualToolsItem>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct UtcpManualToolsItem {
    #[serde(default)]
    pub name: String,
    #[serde(default)]
    pub description: String,
    #[serde(default)]
    pub inputs: serde_json::Value,
    #[serde(default)]
    pub outputs: serde_json::Value,
    #[serde(default)]
    pub tool_call_template: UtcpManualToolsItemToolCallTemplate,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct UtcpManualToolsItemToolCallTemplate {
    #[serde(default)]
    pub call_template_type: String,
    #[serde(default)]
    pub http_method: String,
    #[serde(default)]
    pub url: String,
    #[serde(default)]
    pub content_type: String,
    #[serde(default)]
    pub body_field: String,
    #[serde(default)]
    pub auth: UtcpManualToolsItemToolCallTemplateAuth,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct UtcpManualToolsItemToolCallTemplateAuth {
    #[serde(default)]
    pub auth_type: String,
    #[serde(default)]
    pub api_key: String,
    #[serde(default)]
    pub var_name: String,
    #[serde(default)]
    pub location: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct SetupAuthData {
    #[serde(default)]
    pub status: String,
    #[serde(default)]
    pub message: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SetupAuthRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub show_browser: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct DeAuthData {
    #[serde(default)]
    pub status: String,
    #[serde(default)]
    pub message: String,
    #[serde(default)]
    pub authenticated: bool,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ReAuthData {
    #[serde(default)]
    pub status: String,
    #[serde(default)]
    pub message: String,
    #[serde(default)]
    pub authenticated: bool,
    #[serde(default)]
    pub duration_seconds: f64,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ReAuthRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct AskQuestionData {
    #[serde(default)]
    pub status: String,
    #[serde(default)]
    pub question: String,
    #[serde(default)]
    pub answer: String,
    #[serde(default)]
    pub session_id: String,
    #[serde(default)]
    pub notebook_url: String,
    #[serde(default)]
    pub session_info: AskQuestionDataSessionInfo,
    /// Present when the question asked for a source format other than `none`. The reference's second example, which its first does not show.
    #[serde(default)]
    pub sources: AskQuestionDataSources,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct AskQuestionDataSessionInfo {
    #[serde(default)]
    pub age_seconds: i64,
    #[serde(default)]
    pub message_count: i64,
    #[serde(default)]
    pub last_activity: i64,
}

/// Present when the question asked for a source format other than `none`. The reference's second example, which its first does not show.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct AskQuestionDataSources {
    #[serde(default)]
    pub format: String,
    #[serde(default)]
    pub extraction_success: bool,
    #[serde(default)]
    pub citations: Vec<AskQuestionDataSourcesCitationsItem>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct AskQuestionDataSourcesCitationsItem {
    #[serde(default)]
    pub marker: String,
    #[serde(default)]
    pub number: i64,
    /// The quoted passage. Empty when the citation resolved to a source with no excerpt — reported empty rather than filled with the filename.
    #[serde(rename = "sourceText")]
    #[serde(default)]
    pub source_text: String,
    #[serde(rename = "sourceName")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source_name: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AskRequest {
    #[serde(default)]
    pub question: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub notebook_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub notebook_url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub session_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source_format: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub show_browser: Option<bool>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ListNotebooksData {
    #[serde(default)]
    pub notebooks: Vec<ListNotebooksDataNotebooksItem>,
    #[serde(default)]
    pub count: i64,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ListNotebooksDataNotebooksItem {
    #[serde(default)]
    pub id: String,
    #[serde(default)]
    pub name: String,
    #[serde(default)]
    pub description: String,
    #[serde(default)]
    pub url: String,
    #[serde(default)]
    pub topics: Vec<String>,
    #[serde(default)]
    pub use_cases: Vec<String>,
    #[serde(default)]
    pub active: bool,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct AddNotebookData {
    #[serde(default)]
    pub notebook: AddNotebookDataNotebook,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct AddNotebookDataNotebook {
    #[serde(default)]
    pub id: String,
    #[serde(default)]
    pub name: String,
    #[serde(default)]
    pub description: String,
    #[serde(default)]
    pub url: String,
    #[serde(default)]
    pub topics: Vec<String>,
    #[serde(default)]
    pub content_types: Vec<String>,
    #[serde(default)]
    pub use_cases: Vec<String>,
    #[serde(default)]
    pub added_at: String,
    #[serde(default)]
    pub last_used: String,
    #[serde(default)]
    pub use_count: i64,
    #[serde(default)]
    pub tags: Vec<String>,
    #[serde(default)]
    pub active: bool,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AddNotebookRequest {
    #[serde(default)]
    pub id: String,
    #[serde(default)]
    pub name: String,
    #[serde(default)]
    pub url: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub topics: Option<Vec<String>>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ListNotebooksFromNblmData {
    #[serde(default)]
    pub notebooks: Vec<ListNotebooksFromNblmDataNotebooksItem>,
    #[serde(default)]
    pub total: i64,
    #[serde(default)]
    pub message: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ListNotebooksFromNblmDataNotebooksItem {
    #[serde(default)]
    pub id: String,
    #[serde(default)]
    pub name: String,
    #[serde(default)]
    pub url: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ImportScrapedNotebooksData {
    #[serde(default)]
    pub imported: Vec<ImportScrapedNotebooksDataImportedItem>,
    #[serde(default)]
    pub errors: Vec<ImportScrapedNotebooksDataErrorsItem>,
    #[serde(default)]
    pub total_scraped: i64,
    #[serde(default)]
    pub total_imported: i64,
    #[serde(default)]
    pub total_errors: i64,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ImportScrapedNotebooksDataImportedItem {
    #[serde(default)]
    pub id: String,
    #[serde(default)]
    pub name: String,
    #[serde(default)]
    pub status: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ImportScrapedNotebooksDataErrorsItem {
    #[serde(default)]
    pub id: String,
    #[serde(default)]
    pub name: String,
    #[serde(default)]
    pub error: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct AutoDiscoverNotebookData {
    #[serde(default)]
    pub notebook: AutoDiscoverNotebookDataNotebook,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct AutoDiscoverNotebookDataNotebook {
    #[serde(default)]
    pub id: String,
    #[serde(default)]
    pub url: String,
    #[serde(default)]
    pub name: String,
    #[serde(default)]
    pub description: String,
    #[serde(default)]
    pub topics: Vec<String>,
    #[serde(default)]
    pub content_types: Vec<String>,
    #[serde(default)]
    pub use_cases: Vec<String>,
    #[serde(default)]
    pub added_at: String,
    #[serde(default)]
    pub last_used: String,
    #[serde(default)]
    pub use_count: i64,
    #[serde(default)]
    pub auto_generated: bool,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AutoDiscoverNotebookRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub notebook_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub notebook_url: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct SearchNotebooksData {
    #[serde(default)]
    pub notebooks: Vec<SearchNotebooksDataNotebooksItem>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct SearchNotebooksDataNotebooksItem {
    #[serde(default)]
    pub id: String,
    #[serde(default)]
    pub url: String,
    #[serde(default)]
    pub name: String,
    #[serde(default)]
    pub description: String,
    #[serde(default)]
    pub topics: Vec<String>,
    #[serde(default)]
    pub content_types: Vec<String>,
    #[serde(default)]
    pub use_cases: Vec<String>,
    #[serde(default)]
    pub added_at: String,
    #[serde(default)]
    pub last_used: String,
    #[serde(default)]
    pub use_count: i64,
}

/// Query parameters for [`Client::search_notebooks`].
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct SearchNotebooksQuery {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub q: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct GetLibraryStatsData {
    #[serde(default)]
    pub total_notebooks: i64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub active_notebook_id: Option<String>,
    #[serde(default)]
    pub total_queries: i64,
    #[serde(default)]
    pub most_used_notebook: GetLibraryStatsDataMostUsedNotebook,
    #[serde(default)]
    pub recently_added: Vec<GetLibraryStatsDataRecentlyAddedItem>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct GetLibraryStatsDataMostUsedNotebook {
    #[serde(default)]
    pub id: String,
    #[serde(default)]
    pub name: String,
    #[serde(default)]
    pub use_count: i64,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct GetLibraryStatsDataRecentlyAddedItem {
    #[serde(default)]
    pub id: String,
    #[serde(default)]
    pub name: String,
    #[serde(default)]
    pub added_at: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct DeleteNotebooksFromNblmData {
    #[serde(default)]
    pub deleted: Vec<String>,
    #[serde(default)]
    pub failed: Vec<String>,
    #[serde(default)]
    pub message: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct DeleteNotebooksFromNblmRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ids: Option<Vec<String>>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct GetNotebookData {
    #[serde(default)]
    pub notebook: GetNotebookDataNotebook,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct GetNotebookDataNotebook {
    #[serde(default)]
    pub id: String,
    #[serde(default)]
    pub name: String,
    #[serde(default)]
    pub description: String,
    #[serde(default)]
    pub url: String,
    #[serde(default)]
    pub topics: Vec<String>,
    #[serde(default)]
    pub active: bool,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct UpdateNotebookData {
    #[serde(default)]
    pub notebook: UpdateNotebookDataNotebook,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct UpdateNotebookDataNotebook {
    #[serde(default)]
    pub id: String,
    #[serde(default)]
    pub name: String,
    #[serde(default)]
    pub description: String,
    #[serde(default)]
    pub topics: Vec<String>,
    #[serde(default)]
    pub last_modified: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct RemoveNotebookData {
    #[serde(default)]
    pub message: String,
    #[serde(default)]
    pub id: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct SelectNotebookData {
    #[serde(default)]
    pub message: String,
    #[serde(default)]
    pub notebook: SelectNotebookDataNotebook,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct SelectNotebookDataNotebook {
    #[serde(default)]
    pub id: String,
    #[serde(default)]
    pub name: String,
    #[serde(default)]
    pub description: String,
    #[serde(default)]
    pub url: String,
    #[serde(default)]
    pub topics: Vec<String>,
    #[serde(default)]
    pub active: bool,
    #[serde(default)]
    pub last_used: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct CreateNotebookData {
    #[serde(default)]
    pub notebook_url: String,
    #[serde(default)]
    pub name: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CreateNotebookRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ListSessionsData {
    #[serde(default)]
    pub sessions: Vec<ListSessionsDataSessionsItem>,
    #[serde(default)]
    pub count: i64,
    #[serde(default)]
    pub max_sessions: i64,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ListSessionsDataSessionsItem {
    #[serde(default)]
    pub id: String,
    #[serde(default)]
    pub notebook_url: String,
    #[serde(default)]
    pub message_count: i64,
    #[serde(default)]
    pub age_seconds: i64,
    #[serde(default)]
    pub inactive_seconds: i64,
    #[serde(default)]
    pub last_activity: i64,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct CloseSessionData {
    #[serde(default)]
    pub message: String,
    #[serde(default)]
    pub session_id: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ResetSessionData {
    #[serde(default)]
    pub message: String,
    #[serde(default)]
    pub session_id: String,
    #[serde(default)]
    pub previous_message_count: i64,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct AddSourceData {
    #[serde(default)]
    pub success: bool,
    #[serde(rename = "sourceId")]
    #[serde(default)]
    pub source_id: String,
    #[serde(rename = "sourceName")]
    #[serde(default)]
    pub source_name: String,
    #[serde(default)]
    pub status: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AddSourceRequest {
    #[serde(default)]
    pub source_type: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub file_path: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub text: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub notebook_url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub session_id: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct DeleteSourceData {
    #[serde(default)]
    pub success: bool,
    #[serde(rename = "sourceId")]
    #[serde(default)]
    pub source_id: String,
    #[serde(rename = "sourceName")]
    #[serde(default)]
    pub source_name: String,
}

/// Query parameters for [`Client::delete_source`].
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct DeleteSourceQuery {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct DeleteSourceByIdData {
    #[serde(default)]
    pub success: bool,
    #[serde(rename = "sourceId")]
    #[serde(default)]
    pub source_id: String,
    #[serde(rename = "sourceName")]
    #[serde(default)]
    pub source_name: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct DeleteContentData {
    #[serde(rename = "notebookId")]
    #[serde(default)]
    pub notebook_id: String,
    #[serde(rename = "contentId")]
    #[serde(default)]
    pub content_id: String,
    #[serde(default)]
    pub deleted: bool,
}

/// Query parameters for [`Client::delete_content`].
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct DeleteContentQuery {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub notebook_url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub notebook_id: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ListSourcesData {
    #[serde(rename = "notebookId")]
    #[serde(default)]
    pub notebook_id: String,
    #[serde(default)]
    pub count: i64,
    #[serde(default)]
    pub sources: Vec<ListSourcesDataSourcesItem>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ListSourcesDataSourcesItem {
    #[serde(default)]
    pub id: String,
    #[serde(default)]
    pub title: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ReadSourceData {
    #[serde(default)]
    pub id: String,
    #[serde(default)]
    pub title: String,
    #[serde(rename = "notebookId")]
    #[serde(default)]
    pub notebook_id: String,
    #[serde(default)]
    pub format: String,
    #[serde(default)]
    pub content: String,
    #[serde(rename = "totalChars")]
    #[serde(default)]
    pub total_chars: i64,
    #[serde(rename = "pageChars")]
    #[serde(default)]
    pub page_chars: i64,
    #[serde(default)]
    pub offset: i64,
    #[serde(rename = "hasMore")]
    #[serde(default)]
    pub has_more: bool,
    #[serde(rename = "nextCursor")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub next_cursor: Option<i64>,
    #[serde(rename = "continue")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub continue_: Option<String>,
}

/// Query parameters for [`Client::read_source`].
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ReadSourceQuery {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub format: Option<String>,
    /// Set to `false` to return the whole document in one response.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub paginate: Option<bool>,
    /// Page size in characters. Ignored when `paginate=false`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_chars: Option<i64>,
    /// Resume point — the `nextCursor` returned by the previous page.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cursor: Option<i64>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct RenameSourceData {
    #[serde(rename = "notebookId")]
    #[serde(default)]
    pub notebook_id: String,
    #[serde(rename = "sourceId")]
    #[serde(default)]
    pub source_id: String,
    #[serde(default)]
    pub title: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct RenameSourceRequest {
    #[serde(default)]
    pub title: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct GetSourceGuideData {
    #[serde(rename = "notebookId")]
    #[serde(default)]
    pub notebook_id: String,
    #[serde(default)]
    pub id: String,
    #[serde(default)]
    pub summary: String,
    #[serde(rename = "keyTopics")]
    #[serde(default)]
    pub key_topics: Vec<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct SearchPassagesData {
    #[serde(rename = "notebookId")]
    #[serde(default)]
    pub notebook_id: String,
    #[serde(default)]
    pub query: String,
    #[serde(default)]
    pub count: i64,
    #[serde(default)]
    pub passages: Vec<SearchPassagesDataPassagesItem>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct SearchPassagesDataPassagesItem {
    #[serde(rename = "sourceId")]
    #[serde(default)]
    pub source_id: String,
    #[serde(default)]
    pub text: String,
    #[serde(default)]
    pub rank: i64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub start: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub end: Option<i64>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SearchPassagesRequest {
    #[serde(default)]
    pub query: String,
    /// Restrict to these source UUIDs. Omit to search them all.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source_ids: Option<Vec<String>>,
    /// Restrict by source title; an ambiguous title is an error.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source_names: Option<Vec<String>>,
    /// Keep at most this many passages, best rank first.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct GetNotebookSummaryData {
    #[serde(rename = "notebookId")]
    #[serde(default)]
    pub notebook_id: String,
    #[serde(default)]
    pub summary: String,
    #[serde(rename = "suggestedTopics")]
    #[serde(default)]
    pub suggested_topics: Vec<GetNotebookSummaryDataSuggestedTopicsItem>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct GetNotebookSummaryDataSuggestedTopicsItem {
    #[serde(default)]
    pub question: String,
    #[serde(default)]
    pub prompt: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct CheckSourceFreshnessData {
    #[serde(rename = "notebookId")]
    #[serde(default)]
    pub notebook_id: String,
    #[serde(default)]
    pub checked: i64,
    #[serde(default)]
    pub stale: i64,
    #[serde(default)]
    pub sources: Vec<CheckSourceFreshnessDataSourcesItem>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct CheckSourceFreshnessDataSourcesItem {
    #[serde(default)]
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stale: Option<String>,
}

/// Query parameters for [`Client::check_source_freshness`].
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct CheckSourceFreshnessQuery {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source_id: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct GetChatHistoryData {
    #[serde(rename = "notebookId")]
    #[serde(default)]
    pub notebook_id: String,
    #[serde(rename = "conversationId")]
    #[serde(default)]
    pub conversation_id: String,
    #[serde(default)]
    pub count: i64,
    #[serde(default)]
    pub turns: Vec<GetChatHistoryDataTurnsItem>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct GetChatHistoryDataTurnsItem {
    #[serde(default)]
    pub role: String,
    #[serde(default)]
    pub text: String,
}

/// Query parameters for [`Client::get_chat_history`].
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct GetChatHistoryQuery {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub conversation_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct DeleteChatHistoryData {
    #[serde(rename = "notebookId")]
    #[serde(default)]
    pub notebook_id: String,
    #[serde(rename = "conversationId")]
    #[serde(default)]
    pub conversation_id: String,
    #[serde(default)]
    pub deleted: bool,
}

/// Query parameters for [`Client::delete_chat_history`].
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct DeleteChatHistoryQuery {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub conversation_id: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct GetShareStatusData {
    #[serde(rename = "isPublic")]
    #[serde(default)]
    pub is_public: bool,
    #[serde(rename = "publicLink")]
    #[serde(default)]
    pub public_link: String,
    #[serde(default)]
    pub collaborators: Vec<GetShareStatusDataCollaboratorsItem>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct GetShareStatusDataCollaboratorsItem {
    #[serde(default)]
    pub email: String,
    #[serde(default)]
    pub name: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ShareNotebookData {
    #[serde(rename = "isPublic")]
    #[serde(default)]
    pub is_public: bool,
    #[serde(rename = "publicLink")]
    #[serde(default)]
    pub public_link: String,
    #[serde(default)]
    pub collaborators: Vec<ShareNotebookDataCollaboratorsItem>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ShareNotebookDataCollaboratorsItem {
    #[serde(default)]
    pub email: String,
    #[serde(default)]
    pub name: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ShareNotebookRequest {
    #[serde(default)]
    pub public: bool,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct RetryContentData {
    #[serde(rename = "notebookId")]
    #[serde(default)]
    pub notebook_id: String,
    #[serde(rename = "contentId")]
    #[serde(default)]
    pub content_id: String,
    #[serde(default)]
    pub status: String,
    #[serde(default)]
    pub retried: bool,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct RetryContentRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub notebook_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub notebook_url: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ExportArtifactData {
    #[serde(rename = "notebookId")]
    #[serde(default)]
    pub notebook_id: String,
    #[serde(rename = "artifactId")]
    #[serde(default)]
    pub artifact_id: String,
    #[serde(default)]
    pub target: String,
    #[serde(rename = "documentUrl")]
    #[serde(default)]
    pub document_url: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ExportArtifactRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub notebook_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub notebook_url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub target: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ReviseSlideData {
    #[serde(rename = "notebookId")]
    #[serde(default)]
    pub notebook_id: String,
    #[serde(rename = "artifactId")]
    #[serde(default)]
    pub artifact_id: String,
    #[serde(default)]
    pub status: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ReviseSlideRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub notebook_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub notebook_url: Option<String>,
    #[serde(default)]
    pub slide_index: i64,
    #[serde(default)]
    pub prompt: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ListLabelsData {
    #[serde(default)]
    pub labels: Vec<ListLabelsDataLabelsItem>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ListLabelsDataLabelsItem {
    #[serde(default)]
    pub id: String,
    #[serde(default)]
    pub name: String,
    #[serde(default)]
    pub emoji: String,
    #[serde(rename = "sourceCount")]
    #[serde(default)]
    pub source_count: i64,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ManageLabelsData {
    #[serde(default)]
    pub labels: Vec<ManageLabelsDataLabelsItem>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ManageLabelsDataLabelsItem {
    #[serde(default)]
    pub id: String,
    #[serde(default)]
    pub name: String,
    #[serde(default)]
    pub emoji: String,
    #[serde(rename = "sourceCount")]
    #[serde(default)]
    pub source_count: i64,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ManageLabelsRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub action: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub emoji: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub label_ids: Option<Vec<String>>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct GenerateStudyAidData {
    #[serde(default)]
    pub status: String,
    #[serde(default)]
    pub title: String,
    #[serde(rename = "artifactId")]
    #[serde(default)]
    pub artifact_id: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GenerateStudyAidRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub notebook_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub notebook_url: Option<String>,
    #[serde(default)]
    pub kind: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub focus: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct GenerateMindMapData {
    #[serde(rename = "mindMapId")]
    #[serde(default)]
    pub mind_map_id: String,
    #[serde(default)]
    pub title: String,
    #[serde(default)]
    pub json: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GenerateMindMapRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub notebook_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub notebook_url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ResearchSourcesData {
    #[serde(rename = "taskId")]
    #[serde(default)]
    pub task_id: String,
    #[serde(default)]
    pub imported: i64,
    #[serde(default)]
    pub sources: Vec<ResearchSourcesDataSourcesItem>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ResearchSourcesDataSourcesItem {
    #[serde(default)]
    pub url: String,
    #[serde(default)]
    pub title: String,
    #[serde(default)]
    pub description: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ResearchSourcesRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub notebook_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub notebook_url: Option<String>,
    #[serde(default)]
    pub query: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub import: Option<bool>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct GenerateContentData {
    #[serde(default)]
    pub success: bool,
    #[serde(rename = "type")]
    #[serde(default)]
    pub type_: String,
    #[serde(default)]
    pub status: String,
    #[serde(default)]
    pub message: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GenerateRequest {
    #[serde(default)]
    pub content_type: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub custom_instructions: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub video_style: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub video_format: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub infographic_format: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub report_format: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub presentation_style: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub presentation_length: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct DownloadContentData {
    #[serde(default)]
    pub success: bool,
    #[serde(rename = "filePath")]
    #[serde(default)]
    pub file_path: String,
    #[serde(rename = "mimeType")]
    #[serde(default)]
    pub mime_type: String,
    /// Present when the artifact was exported to Sheets.
    #[serde(rename = "googleSheetsUrl")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub google_sheets_url: Option<String>,
    /// Present when the artifact was exported to Slides.
    #[serde(rename = "googleSlidesUrl")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub google_slides_url: Option<String>,
}

/// Query parameters for [`Client::download_content`].
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct DownloadContentQuery {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub content_id: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ListContentData {
    #[serde(default)]
    pub sources: Vec<ListContentDataSourcesItem>,
    #[serde(rename = "generatedContent")]
    #[serde(default)]
    pub generated_content: Vec<ListContentDataGeneratedContentItem>,
    #[serde(rename = "sourceCount")]
    #[serde(default)]
    pub source_count: i64,
    #[serde(rename = "hasAudioOverview")]
    #[serde(default)]
    pub has_audio_overview: bool,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ListContentDataSourcesItem {
    #[serde(default)]
    pub id: String,
    #[serde(default)]
    pub name: String,
    #[serde(rename = "type")]
    #[serde(default)]
    pub type_: String,
    #[serde(default)]
    pub status: String,
    #[serde(rename = "passageCount")]
    #[serde(default)]
    pub passage_count: i64,
    #[serde(rename = "addedAt")]
    #[serde(default)]
    pub added_at: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ListContentDataGeneratedContentItem {
    #[serde(default)]
    pub id: String,
    #[serde(rename = "type")]
    #[serde(default)]
    pub type_: String,
    #[serde(default)]
    pub name: String,
    #[serde(default)]
    pub status: String,
    #[serde(rename = "createdAt")]
    #[serde(default)]
    pub created_at: String,
    #[serde(default)]
    pub duration: i64,
    #[serde(default)]
    pub url: String,
    #[serde(default)]
    pub content: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct CreateNoteData {
    #[serde(default)]
    pub success: bool,
    #[serde(rename = "noteTitle")]
    #[serde(default)]
    pub note_title: String,
    #[serde(default)]
    pub status: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct SaveChatToNoteData {
    #[serde(default)]
    pub success: bool,
    #[serde(rename = "noteTitle")]
    #[serde(default)]
    pub note_title: String,
    #[serde(default)]
    pub status: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ConvertNoteToSourceData {
    #[serde(default)]
    pub success: bool,
    #[serde(rename = "noteTitle")]
    #[serde(default)]
    pub note_title: String,
    #[serde(default)]
    pub status: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct BatchToVaultData {
    #[serde(default)]
    pub vault_dir: String,
    #[serde(default)]
    pub total: i64,
    #[serde(default)]
    pub succeeded: i64,
    #[serde(default)]
    pub failed: i64,
    #[serde(default)]
    pub session_id: String,
    #[serde(default)]
    pub notebook: BatchToVaultDataNotebook,
    #[serde(default)]
    pub files: Vec<BatchToVaultDataFilesItem>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct BatchToVaultDataNotebook {
    #[serde(default)]
    pub id: String,
    #[serde(default)]
    pub url: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct BatchToVaultDataFilesItem {
    #[serde(default)]
    pub question: String,
    #[serde(default)]
    pub md_path: String,
    #[serde(default)]
    pub json_path: String,
    #[serde(default)]
    pub success: bool,
    #[serde(default)]
    pub citations_count: i64,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct BatchToVaultRequest {
    #[serde(default)]
    pub questions: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub notebook_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub notebook_url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub vault_dir: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub slug_prefix: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source_format: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sleep_between_ms: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub session_id: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ListNotesData {
    #[serde(default)]
    pub success: bool,
    #[serde(default)]
    pub notes: Vec<ListNotesDataNotesItem>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct ListNotesDataNotesItem {
    #[serde(default)]
    pub id: String,
    #[serde(default)]
    pub title: String,
    #[serde(default)]
    pub details: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ListNotesRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub notebook_url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub session_id: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct GetNoteData {
    #[serde(default)]
    pub success: bool,
    #[serde(default)]
    pub title: String,
    #[serde(default)]
    pub content: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetNoteRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub note_title: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub note_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub notebook_url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub session_id: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[non_exhaustive]
pub struct CleanupDataData {
    #[serde(default)]
    pub message: String,
    #[serde(default)]
    pub files_deleted: i64,
    #[serde(default)]
    pub space_freed_mb: f64,
    #[serde(default)]
    pub library_preserved: bool,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CleanupDataRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub confirm: Option<bool>,
}

impl Client {
    /// Server identity, version, and a pointer to the docs
    ///
    /// `GET /`
    pub async fn get_server_info(&self) -> Result<ServerInfo> {
        self.send_raw("get_server_info", reqwest::Method::GET, "/", None::<&()>)
            .await
    }

    /// Server health check
    ///
    /// `GET /health`
    pub async fn get_health(&self) -> Result<GetHealthData> {
        self.send_empty(
            "get_health",
            reqwest::Method::GET,
            "/health",
            None::<&()>,
            None::<&()>,
        )
        .await
    }

    /// UTCP tool manual for this server
    ///
    /// The manual a Universal Tool Calling Protocol client reads before
    /// calling anything. UTCP has no protocol server: the client reads this
    /// once and then calls the routes below natively, so the manual is a
    /// description of this same API rather than a second way into it.
    ///
    /// Generated from this specification, with the call addresses rebased on
    /// the address the request arrived at. The same document is published
    /// statically at `/utcp.json` on the documentation site. Behind the token
    /// guard like every route but `/health`.
    ///
    /// `GET /utcp`
    pub async fn get_utcp_manual(&self) -> Result<UtcpManual> {
        self.send_raw(
            "get_utcp_manual",
            reqwest::Method::GET,
            "/utcp",
            None::<&()>,
        )
        .await
    }

    /// First-time Google authentication (opens visible browser)
    ///
    /// `POST /setup-auth`
    pub async fn setup_auth(&self, body: &SetupAuthRequest) -> Result<SetupAuthData> {
        self.send_json(
            "setup_auth",
            reqwest::Method::POST,
            "/setup-auth",
            Some(body),
            None::<&()>,
        )
        .await
    }

    /// Logout, clear all credentials
    ///
    /// `POST /de-auth`
    pub async fn de_auth(&self) -> Result<DeAuthData> {
        self.send_empty(
            "de_auth",
            reqwest::Method::POST,
            "/de-auth",
            None::<&()>,
            None::<&()>,
        )
        .await
    }

    /// Re-authenticate or switch account
    ///
    /// `POST /re-auth`
    pub async fn re_auth(&self, body: &ReAuthRequest) -> Result<ReAuthData> {
        self.send_json(
            "re_auth",
            reqwest::Method::POST,
            "/re-auth",
            Some(body),
            None::<&()>,
        )
        .await
    }

    /// Ask a question with citation-backed response
    ///
    /// `POST /ask`
    pub async fn ask_question(&self, body: &AskRequest) -> Result<AskQuestionData> {
        self.send_json(
            "ask_question",
            reqwest::Method::POST,
            "/ask",
            Some(body),
            None::<&()>,
        )
        .await
    }

    /// List all notebooks in the local library
    ///
    /// `GET /notebooks`
    pub async fn list_notebooks(&self) -> Result<ListNotebooksData> {
        self.send_empty(
            "list_notebooks",
            reqwest::Method::GET,
            "/notebooks",
            None::<&()>,
            None::<&()>,
        )
        .await
    }

    /// Manually add a notebook to the library
    ///
    /// `POST /notebooks`
    pub async fn add_notebook(&self, body: &AddNotebookRequest) -> Result<AddNotebookData> {
        self.send_json(
            "add_notebook",
            reqwest::Method::POST,
            "/notebooks",
            Some(body),
            None::<&()>,
        )
        .await
    }

    /// Scrape all notebooks from NotebookLM UI
    ///
    /// `GET /notebooks/scrape`
    pub async fn list_notebooks_from_nblm(&self) -> Result<ListNotebooksFromNblmData> {
        self.send_empty(
            "list_notebooks_from_nblm",
            reqwest::Method::GET,
            "/notebooks/scrape",
            None::<&()>,
            None::<&()>,
        )
        .await
    }

    /// Bulk import scraped notebooks into local library
    ///
    /// `POST /notebooks/import-from-scrape`
    pub async fn import_scraped_notebooks(&self) -> Result<ImportScrapedNotebooksData> {
        self.send_empty(
            "import_scraped_notebooks",
            reqwest::Method::POST,
            "/notebooks/import-from-scrape",
            None::<&()>,
            None::<&()>,
        )
        .await
    }

    /// Generate notebook metadata autonomously via NotebookLM queries
    ///
    /// `POST /notebooks/auto-discover`
    pub async fn auto_discover_notebook(
        &self,
        body: &AutoDiscoverNotebookRequest,
    ) -> Result<AutoDiscoverNotebookData> {
        self.send_json(
            "auto_discover_notebook",
            reqwest::Method::POST,
            "/notebooks/auto-discover",
            Some(body),
            None::<&()>,
        )
        .await
    }

    /// Search the local library by keyword
    ///
    /// `GET /notebooks/search`
    pub async fn search_notebooks(
        &self,
        query: &SearchNotebooksQuery,
    ) -> Result<SearchNotebooksData> {
        self.send_empty(
            "search_notebooks",
            reqwest::Method::GET,
            "/notebooks/search",
            None::<&()>,
            Some(query),
        )
        .await
    }

    /// Library statistics
    ///
    /// `GET /notebooks/stats`
    pub async fn get_library_stats(&self) -> Result<GetLibraryStatsData> {
        self.send_empty(
            "get_library_stats",
            reqwest::Method::GET,
            "/notebooks/stats",
            None::<&()>,
            None::<&()>,
        )
        .await
    }

    /// Delete multiple notebooks at once
    ///
    /// `DELETE /notebooks/bulk-delete`
    pub async fn delete_notebooks_from_nblm(
        &self,
        body: &DeleteNotebooksFromNblmRequest,
    ) -> Result<DeleteNotebooksFromNblmData> {
        self.send_json(
            "delete_notebooks_from_nblm",
            reqwest::Method::DELETE,
            "/notebooks/bulk-delete",
            Some(body),
            None::<&()>,
        )
        .await
    }

    /// Get notebook details
    ///
    /// `GET /notebooks/{id}`
    pub async fn get_notebook(&self, id: &str) -> Result<GetNotebookData> {
        self.send_empty(
            "get_notebook",
            reqwest::Method::GET,
            &format!("/notebooks/{id}"),
            None::<&()>,
            None::<&()>,
        )
        .await
    }

    /// Update notebook metadata
    ///
    /// `PUT /notebooks/{id}`
    pub async fn update_notebook(&self, id: &str) -> Result<UpdateNotebookData> {
        self.send_empty(
            "update_notebook",
            reqwest::Method::PUT,
            &format!("/notebooks/{id}"),
            None::<&()>,
            None::<&()>,
        )
        .await
    }

    /// Delete a notebook from the library
    ///
    /// `DELETE /notebooks/{id}`
    pub async fn remove_notebook(&self, id: &str) -> Result<RemoveNotebookData> {
        self.send_empty(
            "remove_notebook",
            reqwest::Method::DELETE,
            &format!("/notebooks/{id}"),
            None::<&()>,
            None::<&()>,
        )
        .await
    }

    /// Set notebook as the default active notebook
    ///
    /// `PUT /notebooks/{id}/activate`
    pub async fn select_notebook(&self, id: &str) -> Result<SelectNotebookData> {
        self.send_empty(
            "select_notebook",
            reqwest::Method::PUT,
            &format!("/notebooks/{id}/activate"),
            None::<&()>,
            None::<&()>,
        )
        .await
    }

    /// Create a new notebook in NotebookLM
    ///
    /// `POST /notebooks/create`
    pub async fn create_notebook(
        &self,
        body: &CreateNotebookRequest,
    ) -> Result<CreateNotebookData> {
        self.send_json(
            "create_notebook",
            reqwest::Method::POST,
            "/notebooks/create",
            Some(body),
            None::<&()>,
        )
        .await
    }

    /// List active sessions
    ///
    /// `GET /sessions`
    pub async fn list_sessions(&self) -> Result<ListSessionsData> {
        self.send_empty(
            "list_sessions",
            reqwest::Method::GET,
            "/sessions",
            None::<&()>,
            None::<&()>,
        )
        .await
    }

    /// Close a session
    ///
    /// `DELETE /sessions/{id}`
    pub async fn close_session(&self, id: &str) -> Result<CloseSessionData> {
        self.send_empty(
            "close_session",
            reqwest::Method::DELETE,
            &format!("/sessions/{id}"),
            None::<&()>,
            None::<&()>,
        )
        .await
    }

    /// Reset a session's history
    ///
    /// `POST /sessions/{id}/reset`
    pub async fn reset_session(&self, id: &str) -> Result<ResetSessionData> {
        self.send_empty(
            "reset_session",
            reqwest::Method::POST,
            &format!("/sessions/{id}/reset"),
            None::<&()>,
            None::<&()>,
        )
        .await
    }

    /// Add a source (file, url, text, youtube, drive) to the active notebook
    ///
    /// `POST /content/sources`
    pub async fn add_source(&self, body: &AddSourceRequest) -> Result<AddSourceData> {
        self.send_json(
            "add_source",
            reqwest::Method::POST,
            "/content/sources",
            Some(body),
            None::<&()>,
        )
        .await
    }

    /// Delete source by name (query parameter)
    ///
    /// `DELETE /content/sources`
    pub async fn delete_source(&self, query: &DeleteSourceQuery) -> Result<DeleteSourceData> {
        self.send_empty(
            "delete_source",
            reqwest::Method::DELETE,
            "/content/sources",
            None::<&()>,
            Some(query),
        )
        .await
    }

    /// Delete source by id
    ///
    /// `DELETE /content/sources/{id}`
    pub async fn delete_source_by_id(&self, id: &str) -> Result<DeleteSourceByIdData> {
        self.send_empty(
            "delete_source_by_id",
            reqwest::Method::DELETE,
            &format!("/content/sources/{id}"),
            None::<&()>,
            None::<&()>,
        )
        .await
    }

    /// Delete a generated Studio artifact
    ///
    /// RPC-backed (no browser). Irreversible. Note-backed mind maps are not
    /// covered — they live in the notes system, not the Studio library.
    ///
    /// `DELETE /content/{contentId}`
    pub async fn delete_content(
        &self,
        content_id: &str,
        query: &DeleteContentQuery,
    ) -> Result<DeleteContentData> {
        self.send_empty(
            "delete_content",
            reqwest::Method::DELETE,
            &format!("/content/{content_id}"),
            None::<&()>,
            Some(query),
        )
        .await
    }

    /// List a notebook's sources with their ids and titles
    ///
    /// RPC-backed (no browser). Returns `{ notebookId, count, sources: [{ id, title }] }`.
    /// This is where the source ids for `/notebooks/{id}/sources/{sourceId}` come from.
    ///
    /// `GET /notebooks/{id}/sources`
    pub async fn list_sources(&self, id: &str) -> Result<ListSourcesData> {
        self.send_empty(
            "list_sources",
            reqwest::Method::GET,
            &format!("/notebooks/{id}/sources"),
            None::<&()>,
            None::<&()>,
        )
        .await
    }

    /// Read a source's indexed text, one page at a time
    ///
    /// RPC-backed (no browser). Returns the exact content NotebookLM reasons
    /// over. Sources are long — the first PDF measured ran to 157,716
    /// characters — so the response is paginated by default and carries
    /// `totalChars`, `pageChars`, `offset`, `hasMore`, `nextCursor` and a
    /// plain-language `continue` instruction. Pages are cut at the nearest
    /// line break (tag close, in HTML), and concatenating every page
    /// reproduces the document exactly. Pass `paginate=false` for the whole
    /// document in one response. The `html` rendition preserves structure but
    /// inlines images as base64 and is bigger.
    ///
    /// `GET /notebooks/{id}/sources/{sourceId}`
    pub async fn read_source(
        &self,
        id: &str,
        source_id: &str,
        query: &ReadSourceQuery,
    ) -> Result<ReadSourceData> {
        self.send_empty(
            "read_source",
            reqwest::Method::GET,
            &format!("/notebooks/{id}/sources/{source_id}"),
            None::<&()>,
            Some(query),
        )
        .await
    }

    /// Rename one source in place
    ///
    /// RPC-backed (no browser). An empty `title` is a 400.
    ///
    /// `PATCH /notebooks/{id}/sources/{sourceId}`
    pub async fn rename_source(
        &self,
        id: &str,
        source_id: &str,
        body: &RenameSourceRequest,
    ) -> Result<RenameSourceData> {
        self.send_json(
            "rename_source",
            reqwest::Method::PATCH,
            &format!("/notebooks/{id}/sources/{source_id}"),
            Some(body),
            None::<&()>,
        )
        .await
    }

    /// NotebookLM's own summary and key topics for one source
    ///
    /// RPC-backed (no browser). A source NotebookLM has not summarised yet
    /// returns an empty `summary` and no topics.
    ///
    /// `GET /notebooks/{id}/sources/{sourceId}/guide`
    pub async fn get_source_guide(&self, id: &str, source_id: &str) -> Result<GetSourceGuideData> {
        self.send_empty(
            "get_source_guide",
            reqwest::Method::GET,
            &format!("/notebooks/{id}/sources/{source_id}/guide"),
            None::<&()>,
            None::<&()>,
        )
        .await
    }

    /// Ranked passages from the notebook's index, without generating an answer
    ///
    /// RPC-backed (no browser). Retrieval rather than question answering:
    /// nothing is generated and no generation quota is spent. Rank is global
    /// across sources and lower is better. `start` / `end` are character
    /// offsets into the source's full text, and are `null` when the server
    /// did not give them.
    ///
    /// `POST /notebooks/{id}/search`
    pub async fn search_passages(
        &self,
        id: &str,
        body: &SearchPassagesRequest,
    ) -> Result<SearchPassagesData> {
        self.send_json(
            "search_passages",
            reqwest::Method::POST,
            &format!("/notebooks/{id}/search"),
            Some(body),
            None::<&()>,
        )
        .await
    }

    /// A notebook's own summary of its sources, and the questions it suggests
    ///
    /// RPC-backed (no browser). Cheaper than asking a question to find out
    /// what a notebook holds.
    ///
    /// `GET /notebooks/{id}/summary`
    pub async fn get_notebook_summary(&self, id: &str) -> Result<GetNotebookSummaryData> {
        self.send_empty(
            "get_notebook_summary",
            reqwest::Method::GET,
            &format!("/notebooks/{id}/summary"),
            None::<&()>,
            None::<&()>,
        )
        .await
    }

    /// Have the notebook's URL / Drive sources drifted?
    ///
    /// RPC-backed (no browser). Checks every source unless `source_id`
    /// narrows it. `stale: null` means the server did not answer for that
    /// source — not that it is current.
    ///
    /// `GET /notebooks/{id}/freshness`
    pub async fn check_source_freshness(
        &self,
        id: &str,
        query: &CheckSourceFreshnessQuery,
    ) -> Result<CheckSourceFreshnessData> {
        self.send_empty(
            "check_source_freshness",
            reqwest::Method::GET,
            &format!("/notebooks/{id}/freshness"),
            None::<&()>,
            Some(query),
        )
        .await
    }

    /// Read back the recorded questions and answers, newest first
    ///
    /// RPC-backed (no browser). NotebookLM exposes only the most recent
    /// conversation per notebook; older ones cannot be listed.
    ///
    /// `GET /notebooks/{id}/chat`
    pub async fn get_chat_history(
        &self,
        id: &str,
        query: &GetChatHistoryQuery,
    ) -> Result<GetChatHistoryData> {
        self.send_empty(
            "get_chat_history",
            reqwest::Method::GET,
            &format!("/notebooks/{id}/chat"),
            None::<&()>,
            Some(query),
        )
        .await
    }

    /// Clear the chat history
    ///
    /// The web UI's "Delete history". NotebookLM has no per-turn delete, so
    /// the whole conversation goes. Nothing to delete is reported as
    /// `deleted: false`, not as a failure.
    ///
    /// `DELETE /notebooks/{id}/chat`
    pub async fn delete_chat_history(
        &self,
        id: &str,
        query: &DeleteChatHistoryQuery,
    ) -> Result<DeleteChatHistoryData> {
        self.send_empty(
            "delete_chat_history",
            reqwest::Method::DELETE,
            &format!("/notebooks/{id}/chat"),
            None::<&()>,
            Some(query),
        )
        .await
    }

    /// Read a notebook's sharing status
    ///
    /// `GET /notebooks/{id}/share`
    pub async fn get_share_status(&self, id: &str) -> Result<GetShareStatusData> {
        self.send_empty(
            "get_share_status",
            reqwest::Method::GET,
            &format!("/notebooks/{id}/share"),
            None::<&()>,
            None::<&()>,
        )
        .await
    }

    /// Toggle the public link
    ///
    /// `PUT /notebooks/{id}/share`
    pub async fn share_notebook(
        &self,
        id: &str,
        body: &ShareNotebookRequest,
    ) -> Result<ShareNotebookData> {
        self.send_json(
            "share_notebook",
            reqwest::Method::PUT,
            &format!("/notebooks/{id}/share"),
            Some(body),
            None::<&()>,
        )
        .await
    }

    /// Retry a failed generation, keeping the same artifact id
    ///
    /// RPC-backed. The artifact is not deleted and not replaced: the same id
    /// goes back to `generating`, so a reference the caller already holds
    /// stays valid. Deleting and regenerating instead mints a new id.
    ///
    /// A refusal (rate limit, quota, or an artifact the backend will not
    /// retry) comes back as an error. An accepted retry can still fail again
    /// on Google's side — poll `GET /content` for the outcome.
    ///
    /// `POST /content/{artifactId}/retry`
    pub async fn retry_content(
        &self,
        artifact_id: &str,
        body: &RetryContentRequest,
    ) -> Result<RetryContentData> {
        self.send_json(
            "retry_content",
            reqwest::Method::POST,
            &format!("/content/{artifact_id}/retry"),
            Some(body),
            None::<&()>,
        )
        .await
    }

    /// Export a finished artifact to Google Docs or Sheets
    ///
    /// RPC-backed. `documentUrl` is `null` when the reply carried no Drive
    /// link — the export may still have succeeded; check Drive.
    ///
    /// `POST /content/{artifactId}/export`
    pub async fn export_artifact(
        &self,
        artifact_id: &str,
        body: &ExportArtifactRequest,
    ) -> Result<ExportArtifactData> {
        self.send_json(
            "export_artifact",
            reqwest::Method::POST,
            &format!("/content/{artifact_id}/export"),
            Some(body),
            None::<&()>,
        )
        .await
    }

    /// Revise one slide of an existing deck from a prompt
    ///
    /// RPC-backed. `slide_index` is zero-based. Returns as soon as the
    /// revision is accepted; poll `GET /content` for the finished deck.
    ///
    /// `POST /content/{artifactId}/revise-slide`
    pub async fn revise_slide(
        &self,
        artifact_id: &str,
        body: &ReviseSlideRequest,
    ) -> Result<ReviseSlideData> {
        self.send_json(
            "revise_slide",
            reqwest::Method::POST,
            &format!("/content/{artifact_id}/revise-slide"),
            Some(body),
            None::<&()>,
        )
        .await
    }

    /// List a notebook's source labels
    ///
    /// `GET /notebooks/{id}/labels`
    pub async fn list_labels(&self, id: &str) -> Result<ListLabelsData> {
        self.send_empty(
            "list_labels",
            reqwest::Method::GET,
            &format!("/notebooks/{id}/labels"),
            None::<&()>,
            None::<&()>,
        )
        .await
    }

    /// Create or delete source labels
    ///
    /// `POST /notebooks/{id}/labels`
    pub async fn manage_labels(
        &self,
        id: &str,
        body: &ManageLabelsRequest,
    ) -> Result<ManageLabelsData> {
        self.send_json(
            "manage_labels",
            reqwest::Method::POST,
            &format!("/notebooks/{id}/labels"),
            Some(body),
            None::<&()>,
        )
        .await
    }

    /// Generate a study aid (flashcards or quiz)
    ///
    /// `POST /content/study-aid`
    pub async fn generate_study_aid(
        &self,
        body: &GenerateStudyAidRequest,
    ) -> Result<GenerateStudyAidData> {
        self.send_json(
            "generate_study_aid",
            reqwest::Method::POST,
            "/content/study-aid",
            Some(body),
            None::<&()>,
        )
        .await
    }

    /// Generate and save a mind map
    ///
    /// `POST /content/mind-map`
    pub async fn generate_mind_map(
        &self,
        body: &GenerateMindMapRequest,
    ) -> Result<GenerateMindMapData> {
        self.send_json(
            "generate_mind_map",
            reqwest::Method::POST,
            "/content/mind-map",
            Some(body),
            None::<&()>,
        )
        .await
    }

    /// Discover web sources for a notebook (Fast Research), optionally importing them
    ///
    /// `POST /content/research`
    pub async fn research_sources(
        &self,
        body: &ResearchSourcesRequest,
    ) -> Result<ResearchSourcesData> {
        self.send_json(
            "research_sources",
            reqwest::Method::POST,
            "/content/research",
            Some(body),
            None::<&()>,
        )
        .await
    }

    /// Generate Studio content (audio, video, infographic, report, presentation, data table)
    ///
    /// `POST /content/generate`
    pub async fn generate_content(&self, body: &GenerateRequest) -> Result<GenerateContentData> {
        self.send_json(
            "generate_content",
            reqwest::Method::POST,
            "/content/generate",
            Some(body),
            None::<&()>,
        )
        .await
    }

    /// Download a generated artifact (WAV, MP4, PNG)
    ///
    /// `GET /content/download`
    pub async fn download_content(
        &self,
        query: &DownloadContentQuery,
    ) -> Result<DownloadContentData> {
        self.send_empty(
            "download_content",
            reqwest::Method::GET,
            "/content/download",
            None::<&()>,
            Some(query),
        )
        .await
    }

    /// List sources and generated content for the active notebook
    ///
    /// `GET /content`
    pub async fn list_content(&self) -> Result<ListContentData> {
        self.send_empty(
            "list_content",
            reqwest::Method::GET,
            "/content",
            None::<&()>,
            None::<&()>,
        )
        .await
    }

    /// Create a note in the active notebook
    ///
    /// `POST /content/notes`
    pub async fn create_note(&self) -> Result<CreateNoteData> {
        self.send_empty(
            "create_note",
            reqwest::Method::POST,
            "/content/notes",
            None::<&()>,
            None::<&()>,
        )
        .await
    }

    /// Save the current chat discussion as a note
    ///
    /// `POST /content/chat-to-note`
    pub async fn save_chat_to_note(&self) -> Result<SaveChatToNoteData> {
        self.send_empty(
            "save_chat_to_note",
            reqwest::Method::POST,
            "/content/chat-to-note",
            None::<&()>,
            None::<&()>,
        )
        .await
    }

    /// Convert a note into a NotebookLM source
    ///
    /// `POST /content/notes/{noteTitle}/to-source`
    pub async fn convert_note_to_source(
        &self,
        note_title: &str,
    ) -> Result<ConvertNoteToSourceData> {
        self.send_empty(
            "convert_note_to_source",
            reqwest::Method::POST,
            &format!("/content/notes/{note_title}/to-source"),
            None::<&()>,
            None::<&()>,
        )
        .await
    }

    /// Run a batch of questions and write each answer to a vault directory
    ///
    /// Long-running: one NotebookLM answer per question, written as a markdown
    /// file conforming to the `nblm-answer-v1` schema. Size the client timeout
    /// accordingly (and the reverse-proxy read timeout, if any).
    ///
    /// `POST /batch-to-vault`
    pub async fn batch_to_vault(&self, body: &BatchToVaultRequest) -> Result<BatchToVaultData> {
        self.send_json(
            "batch_to_vault",
            reqwest::Method::POST,
            "/batch-to-vault",
            Some(body),
            None::<&()>,
        )
        .await
    }

    /// List the notebook's notes
    ///
    /// `POST /content/notes/list`
    pub async fn list_notes(&self, body: &ListNotesRequest) -> Result<ListNotesData> {
        self.send_json(
            "list_notes",
            reqwest::Method::POST,
            "/content/notes/list",
            Some(body),
            None::<&()>,
        )
        .await
    }

    /// Read one note's content, by title or id
    ///
    /// `POST /content/notes/get`
    pub async fn get_note(&self, body: &GetNoteRequest) -> Result<GetNoteData> {
        self.send_json(
            "get_note",
            reqwest::Method::POST,
            "/content/notes/get",
            Some(body),
            None::<&()>,
        )
        .await
    }

    /// Wipe all local data (requires confirmation)
    ///
    /// `POST /cleanup-data`
    pub async fn cleanup_data(&self, body: &CleanupDataRequest) -> Result<CleanupDataData> {
        self.send_json(
            "cleanup_data",
            reqwest::Method::POST,
            "/cleanup-data",
            Some(body),
            None::<&()>,
        )
        .await
    }
}