Scheduled reports and the weekly digest

An administrator picks sections, a schedule (daily, weekly or monthly,
at a time in a time zone) and recipients, who must be accounts on this
server. Every node looks for due reports once a minute; a run is claimed
with the task lock, keyed by report and due time, and recorded on the
report, so it goes once. The report is built from what the server
already keeps: mail flow, the queue, spoofing from received DMARC
reports, TLS failures, deliverability findings and what changed since
the last run, security counters, people near their quota, and expiring
certificates. It is mailed as text and HTML with optional CSV
attachments, DKIM-signed; a sender domain without a key fails the run
with that reason instead of sending unsigned.

The weekly digest is a built-in report on every server, on by default:
every section, Mondays 07:00 UTC, to the system administrators. It can
be changed or turned off, not deleted. A tenant administrator makes and
sees only their own tenant's reports, which leave out server-wide
sections.

New: inbuxa:ScheduledReport and inbuxa:ScheduledReportSettings, the
sysScheduledReportGet and sysScheduledReportUpdate permissions (granted
once to existing administrator roles), privacy catalog entries, and a
system test. Spec: inbuxa-drafts specs/scheduled-reports.md.

crates/jmap-proto/src/object/inbuxa_scheduled_report.rs

@@ -0,0 +1,190 @@
+/*
+ * SPDX-FileCopyrightText: 2026 Coffey Labs LLC
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+//! `inbuxa:ScheduledReport/get` and `/set` under `urn:inbuxa:jmap`: reports
+//! the server builds and mails on a schedule, the weekly digest among them
+//! (scheduled-reports spec).
+
+use crate::object::{AnyId, JmapObject, JmapObjectId};
+use jmap_tools::{Element, Key, Property};
+use std::{borrow::Cow, str::FromStr};
+use types::id::Id;
+
+#[derive(Debug, Clone, Default)]
+pub struct ScheduledReport;
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum ScheduledReportProperty {
+    Id,
+    Name,
+    Enabled,
+    BuiltIn,
+    Sections,
+    Schedule,
+    Recipients,
+    AttachCsv,
+    MemberTenantId,
+    CreatedAt,
+    NextRunAt,
+    Runs,
+    SendNow,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum ScheduledReportValue {
+    Id(Id),
+}
+
+impl Property for ScheduledReportProperty {
+    fn try_parse(parent: Option<&Key<'_, Self>>, value: &str) -> Option<Self> {
+        // Keys inside objects (the schedule, a run) stay plain keys
+        match parent {
+            None => ScheduledReportProperty::parse(value),
+            Some(_) => None,
+        }
+    }
+
+    fn to_cow(&self) -> Cow<'static, str> {
+        match self {
+            ScheduledReportProperty::Id => "id",
+            ScheduledReportProperty::Name => "name",
+            ScheduledReportProperty::Enabled => "enabled",
+            ScheduledReportProperty::BuiltIn => "builtIn",
+            ScheduledReportProperty::Sections => "sections",
+            ScheduledReportProperty::Schedule => "schedule",
+            ScheduledReportProperty::Recipients => "recipients",
+            ScheduledReportProperty::AttachCsv => "attachCsv",
+            ScheduledReportProperty::MemberTenantId => "memberTenantId",
+            ScheduledReportProperty::CreatedAt => "createdAt",
+            ScheduledReportProperty::NextRunAt => "nextRunAt",
+            ScheduledReportProperty::Runs => "runs",
+            ScheduledReportProperty::SendNow => "sendNow",
+        }
+        .into()
+    }
+}
+
+impl ScheduledReportProperty {
+    fn parse(value: &str) -> Option<Self> {
+        hashify::tiny_map!(value.as_bytes(),
+            b"id" => ScheduledReportProperty::Id,
+            b"name" => ScheduledReportProperty::Name,
+            b"enabled" => ScheduledReportProperty::Enabled,
+            b"builtIn" => ScheduledReportProperty::BuiltIn,
+            b"sections" => ScheduledReportProperty::Sections,
+            b"schedule" => ScheduledReportProperty::Schedule,
+            b"recipients" => ScheduledReportProperty::Recipients,
+            b"attachCsv" => ScheduledReportProperty::AttachCsv,
+            b"memberTenantId" => ScheduledReportProperty::MemberTenantId,
+            b"createdAt" => ScheduledReportProperty::CreatedAt,
+            b"nextRunAt" => ScheduledReportProperty::NextRunAt,
+            b"runs" => ScheduledReportProperty::Runs,
+            b"sendNow" => ScheduledReportProperty::SendNow,
+        )
+    }
+}
+
+impl FromStr for ScheduledReportProperty {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        ScheduledReportProperty::parse(s).ok_or(())
+    }
+}
+
+impl Element for ScheduledReportValue {
+    type Property = ScheduledReportProperty;
+
+    fn try_parse<P>(key: &Key<'_, Self::Property>, value: &str) -> Option<Self> {
+        match key {
+            Key::Property(ScheduledReportProperty::Id) => {
+                Id::from_str(value).ok().map(ScheduledReportValue::Id)
+            }
+            _ => None,
+        }
+    }
+
+    fn to_cow(&self) -> Cow<'static, str> {
+        match self {
+            ScheduledReportValue::Id(id) => id.to_string().into(),
+        }
+    }
+}
+
+impl JmapObject for ScheduledReport {
+    type Property = ScheduledReportProperty;
+
+    type Element = ScheduledReportValue;
+
+    type Id = Id;
+
+    type Filter = ();
+
+    type Comparator = ();
+
+    type GetArguments = ();
+
+    type SetArguments<'de> = ();
+
+    type QueryArguments = ();
+
+    type CopyArguments = ();
+
+    type ParseArguments = ();
+
+    const ID_PROPERTY: Self::Property = ScheduledReportProperty::Id;
+}
+
+impl From<Id> for ScheduledReportValue {
+    fn from(id: Id) -> Self {
+        ScheduledReportValue::Id(id)
+    }
+}
+
+impl JmapObjectId for ScheduledReportValue {
+    fn as_id(&self) -> Option<Id> {
+        match self {
+            ScheduledReportValue::Id(id) => Some(*id),
+        }
+    }
+
+    fn as_any_id(&self) -> Option<AnyId> {
+        match self {
+            ScheduledReportValue::Id(id) => Some(AnyId::Id(*id)),
+        }
+    }
+
+    fn as_id_ref(&self) -> Option<&str> {
+        None
+    }
+
+    fn try_set_id(&mut self, new_id: AnyId) -> bool {
+        if let AnyId::Id(id) = new_id {
+            *self = ScheduledReportValue::Id(id);
+            true
+        } else {
+            false
+        }
+    }
+}
+
+impl JmapObjectId for ScheduledReportProperty {
+    fn as_id(&self) -> Option<Id> {
+        None
+    }
+
+    fn as_any_id(&self) -> Option<AnyId> {
+        None
+    }
+
+    fn as_id_ref(&self) -> Option<&str> {
+        None
+    }
+
+    fn try_set_id(&mut self, _: AnyId) -> bool {
+        false
+    }
+}

crates/jmap-proto/src/object/inbuxa_scheduled_report_settings.rs

@@ -0,0 +1,159 @@
+/*
+ * SPDX-FileCopyrightText: 2026 Coffey Labs LLC
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+//! `inbuxa:ScheduledReportSettings/get` and `/set` under `urn:inbuxa:jmap`:
+//! who scheduled reports come from (scheduled-reports spec, RP-20).
+
+use crate::object::{AnyId, JmapObject, JmapObjectId};
+use jmap_tools::{Element, Key, Property};
+use std::{borrow::Cow, str::FromStr};
+use types::id::Id;
+
+#[derive(Debug, Clone, Default)]
+pub struct ScheduledReportSettings;
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum ScheduledReportSettingsProperty {
+    Id,
+    FromName,
+    FromAddress,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum ScheduledReportSettingsValue {
+    Id(Id),
+}
+
+impl Property for ScheduledReportSettingsProperty {
+    fn try_parse(parent: Option<&Key<'_, Self>>, value: &str) -> Option<Self> {
+        // Keys inside objects (the schedule, a run) stay plain keys
+        match parent {
+            None => ScheduledReportSettingsProperty::parse(value),
+            Some(_) => None,
+        }
+    }
+
+    fn to_cow(&self) -> Cow<'static, str> {
+        match self {
+            ScheduledReportSettingsProperty::Id => "id",
+            ScheduledReportSettingsProperty::FromName => "fromName",
+            ScheduledReportSettingsProperty::FromAddress => "fromAddress",
+        }
+        .into()
+    }
+}
+
+impl ScheduledReportSettingsProperty {
+    fn parse(value: &str) -> Option<Self> {
+        hashify::tiny_map!(value.as_bytes(),
+            b"id" => ScheduledReportSettingsProperty::Id,
+            b"fromName" => ScheduledReportSettingsProperty::FromName,
+            b"fromAddress" => ScheduledReportSettingsProperty::FromAddress,
+        )
+    }
+}
+
+impl FromStr for ScheduledReportSettingsProperty {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        ScheduledReportSettingsProperty::parse(s).ok_or(())
+    }
+}
+
+impl Element for ScheduledReportSettingsValue {
+    type Property = ScheduledReportSettingsProperty;
+
+    fn try_parse<P>(key: &Key<'_, Self::Property>, value: &str) -> Option<Self> {
+        match key {
+            Key::Property(ScheduledReportSettingsProperty::Id) => Id::from_str(value)
+                .ok()
+                .map(ScheduledReportSettingsValue::Id),
+            _ => None,
+        }
+    }
+
+    fn to_cow(&self) -> Cow<'static, str> {
+        match self {
+            ScheduledReportSettingsValue::Id(id) => id.to_string().into(),
+        }
+    }
+}
+
+impl JmapObject for ScheduledReportSettings {
+    type Property = ScheduledReportSettingsProperty;
+
+    type Element = ScheduledReportSettingsValue;
+
+    type Id = Id;
+
+    type Filter = ();
+
+    type Comparator = ();
+
+    type GetArguments = ();
+
+    type SetArguments<'de> = ();
+
+    type QueryArguments = ();
+
+    type CopyArguments = ();
+
+    type ParseArguments = ();
+
+    const ID_PROPERTY: Self::Property = ScheduledReportSettingsProperty::Id;
+}
+
+impl From<Id> for ScheduledReportSettingsValue {
+    fn from(id: Id) -> Self {
+        ScheduledReportSettingsValue::Id(id)
+    }
+}
+
+impl JmapObjectId for ScheduledReportSettingsValue {
+    fn as_id(&self) -> Option<Id> {
+        match self {
+            ScheduledReportSettingsValue::Id(id) => Some(*id),
+        }
+    }
+
+    fn as_any_id(&self) -> Option<AnyId> {
+        match self {
+            ScheduledReportSettingsValue::Id(id) => Some(AnyId::Id(*id)),
+        }
+    }
+
+    fn as_id_ref(&self) -> Option<&str> {
+        None
+    }
+
+    fn try_set_id(&mut self, new_id: AnyId) -> bool {
+        if let AnyId::Id(id) = new_id {
+            *self = ScheduledReportSettingsValue::Id(id);
+            true
+        } else {
+            false
+        }
+    }
+}
+
+impl JmapObjectId for ScheduledReportSettingsProperty {
+    fn as_id(&self) -> Option<Id> {
+        None
+    }
+
+    fn as_any_id(&self) -> Option<AnyId> {
+        None
+    }
+
+    fn as_id_ref(&self) -> Option<&str> {
+        None
+    }
+
+    fn try_set_id(&mut self, _: AnyId) -> bool {
+        false
+    }
+}

crates/jmap-proto/src/object/mod.rs

@@ -33,6 +33,8 @@ pub mod inbuxa_mail_rule; // inbuxa: DLP and mail flow rules
 pub mod inbuxa_security_acceptance; // inbuxa: accepted security to-do items
 pub mod inbuxa_deliverability_report; // inbuxa: the deliverability check
 pub mod inbuxa_deliverability_settings; // inbuxa: the deliverability check
+pub mod inbuxa_scheduled_report; // inbuxa: scheduled reports
+pub mod inbuxa_scheduled_report_settings; // inbuxa: scheduled reports
 pub mod inbuxa_journal; // inbuxa: journaling
 pub mod inbuxa_journal_entry; // inbuxa: journaling, search and export
 pub mod inbuxa_held_message; // inbuxa: mail held for review

crates/jmap-proto/src/references/eval.rs

@@ -97,6 +97,12 @@ impl Response<'_> {
                         GetResponseMethod::DeliverabilitySettings(response) => {
                             response.eval_jptr(path, &mut results)
                         }
+                        GetResponseMethod::ScheduledReport(response) => {
+                            response.eval_jptr(path, &mut results)
+                        }
+                        GetResponseMethod::ScheduledReportSettings(response) => {
+                            response.eval_jptr(path, &mut results)
+                        }
                         GetResponseMethod::Journal(response) => {
                             response.eval_jptr(path, &mut results)
                         }

crates/jmap-proto/src/references/resolve.rs

@@ -58,6 +58,8 @@ impl Response<'_> {
                 GetRequestMethod::SecurityAcceptance(request) => request.resolve_references(self)?,
                 GetRequestMethod::DeliverabilityReport(request) => request.resolve_references(self)?,
                 GetRequestMethod::DeliverabilitySettings(request) => request.resolve_references(self)?,
+                GetRequestMethod::ScheduledReport(request) => request.resolve_references(self)?,
+                GetRequestMethod::ScheduledReportSettings(request) => request.resolve_references(self)?,
                 GetRequestMethod::Journal(request) => request.resolve_references(self)?,
                 GetRequestMethod::JournalEntry(request) => request.resolve_references(self)?,
                 GetRequestMethod::HeldMessage(request) => request.resolve_references(self)?,
@@ -148,6 +150,12 @@ impl Response<'_> {
                 SetRequestMethod::DeliverabilitySettings(request) => {
                     request.resolve_references(self, 1, false)?
                 }
+                SetRequestMethod::ScheduledReport(request) => {
+                    request.resolve_references(self, 1, false)?
+                }
+                SetRequestMethod::ScheduledReportSettings(request) => {
+                    request.resolve_references(self, 1, false)?
+                }
                 SetRequestMethod::Journal(request) => {
                     request.resolve_references(self, 1, false)?
                 }

crates/jmap-proto/src/request/method.rs

@@ -73,6 +73,8 @@ pub enum MethodObject {
     // inbuxa: the deliverability check
     DeliverabilityReport,
     DeliverabilitySettings,
+    ScheduledReport,
+    ScheduledReportSettings,
     HeldMessage,
     // inbuxa: journaling
     Journal,
@@ -124,6 +126,8 @@ impl MethodObject {
             | MethodObject::HeldMessage
             | MethodObject::DeliverabilityReport
             | MethodObject::DeliverabilitySettings
+            | MethodObject::ScheduledReport
+            | MethodObject::ScheduledReportSettings
             | MethodObject::Journal
             | MethodObject::JournalEntry
             | MethodObject::JournalExport
@@ -332,6 +336,10 @@ impl MethodName {
             (MethodFunction::Set, MethodObject::DeliverabilityReport) => "inbuxa:DeliverabilityReport/set",
             (MethodFunction::Get, MethodObject::DeliverabilitySettings) => "inbuxa:DeliverabilitySettings/get",
             (MethodFunction::Set, MethodObject::DeliverabilitySettings) => "inbuxa:DeliverabilitySettings/set",
+            (MethodFunction::Get, MethodObject::ScheduledReport) => "inbuxa:ScheduledReport/get",
+            (MethodFunction::Set, MethodObject::ScheduledReport) => "inbuxa:ScheduledReport/set",
+            (MethodFunction::Get, MethodObject::ScheduledReportSettings) => "inbuxa:ScheduledReportSettings/get",
+            (MethodFunction::Set, MethodObject::ScheduledReportSettings) => "inbuxa:ScheduledReportSettings/set",
             (MethodFunction::Get, MethodObject::Journal) => "inbuxa:Journal/get",
             (MethodFunction::Set, MethodObject::Journal) => "inbuxa:Journal/set",
             (MethodFunction::Get, MethodObject::JournalEntry) => "inbuxa:JournalEntry/get",
@@ -510,6 +518,10 @@ impl MethodName {
             "inbuxa:DeliverabilityReport/set" => (MethodObject::DeliverabilityReport, MethodFunction::Set),
             "inbuxa:DeliverabilitySettings/get" => (MethodObject::DeliverabilitySettings, MethodFunction::Get),
             "inbuxa:DeliverabilitySettings/set" => (MethodObject::DeliverabilitySettings, MethodFunction::Set),
+            "inbuxa:ScheduledReport/get" => (MethodObject::ScheduledReport, MethodFunction::Get),
+            "inbuxa:ScheduledReport/set" => (MethodObject::ScheduledReport, MethodFunction::Set),
+            "inbuxa:ScheduledReportSettings/get" => (MethodObject::ScheduledReportSettings, MethodFunction::Get),
+            "inbuxa:ScheduledReportSettings/set" => (MethodObject::ScheduledReportSettings, MethodFunction::Set),
             "inbuxa:Journal/get" => (MethodObject::Journal, MethodFunction::Get),
             "inbuxa:Journal/set" => (MethodObject::Journal, MethodFunction::Set),
             "inbuxa:JournalEntry/get" => (MethodObject::JournalEntry, MethodFunction::Get),
@@ -595,6 +607,8 @@ impl Display for MethodObject {
             MethodObject::SecurityAcceptance => "inbuxa:SecurityAcceptance",
             MethodObject::DeliverabilityReport => "inbuxa:DeliverabilityReport",
             MethodObject::DeliverabilitySettings => "inbuxa:DeliverabilitySettings",
+            MethodObject::ScheduledReport => "inbuxa:ScheduledReport",
+            MethodObject::ScheduledReportSettings => "inbuxa:ScheduledReportSettings",
             MethodObject::Journal => "inbuxa:Journal",
             MethodObject::JournalEntry => "inbuxa:JournalEntry",
             MethodObject::JournalExport => "inbuxa:JournalExport",

crates/jmap-proto/src/request/mod.rs

@@ -128,6 +128,8 @@ pub enum GetRequestMethod {
     SecurityAcceptance(Box<GetRequest<crate::object::inbuxa_security_acceptance::SecurityAcceptance>>),
     DeliverabilityReport(Box<GetRequest<crate::object::inbuxa_deliverability_report::DeliverabilityReport>>),
     DeliverabilitySettings(Box<GetRequest<crate::object::inbuxa_deliverability_settings::DeliverabilitySettings>>),
+    ScheduledReport(Box<GetRequest<crate::object::inbuxa_scheduled_report::ScheduledReport>>),
+    ScheduledReportSettings(Box<GetRequest<crate::object::inbuxa_scheduled_report_settings::ScheduledReportSettings>>),
     Journal(Box<GetRequest<crate::object::inbuxa_journal::Journal>>),
     JournalEntry(Box<GetRequest<crate::object::inbuxa_journal_entry::JournalEntry>>),
     HeldMessage(Box<GetRequest<crate::object::inbuxa_held_message::HeldMessage>>),
@@ -176,6 +178,8 @@ pub enum SetRequestMethod<'x> {
     ),
     DeliverabilityReport(Box<SetRequest<'x, crate::object::inbuxa_deliverability_report::DeliverabilityReport>>),
     DeliverabilitySettings(Box<SetRequest<'x, crate::object::inbuxa_deliverability_settings::DeliverabilitySettings>>),
+    ScheduledReport(Box<SetRequest<'x, crate::object::inbuxa_scheduled_report::ScheduledReport>>),
+    ScheduledReportSettings(Box<SetRequest<'x, crate::object::inbuxa_scheduled_report_settings::ScheduledReportSettings>>),
     Journal(Box<SetRequest<'x, crate::object::inbuxa_journal::Journal>>),
     JournalExport(Box<SetRequest<'x, crate::object::inbuxa_journal_entry::JournalExport>>),
     JournalVerification(Box<SetRequest<'x, crate::object::inbuxa_journal_entry::JournalVerification>>),

crates/jmap-proto/src/request/parser.rs

@@ -715,6 +715,34 @@ impl<'de> Visitor<'de> for CallVisitor {
                     return Err(de::Error::invalid_length(1, &self));
                 }
             },
+            (MethodFunction::Get, MethodObject::ScheduledReport) => match seq.next_element() {
+                Ok(Some(value)) => RequestMethod::Get(GetRequestMethod::ScheduledReport(value)),
+                Err(err) => RequestMethod::invalid(err),
+                Ok(None) => {
+                    return Err(de::Error::invalid_length(1, &self));
+                }
+            },
+            (MethodFunction::Set, MethodObject::ScheduledReport) => match seq.next_element() {
+                Ok(Some(value)) => RequestMethod::Set(SetRequestMethod::ScheduledReport(value)),
+                Err(err) => RequestMethod::invalid(err),
+                Ok(None) => {
+                    return Err(de::Error::invalid_length(1, &self));
+                }
+            },
+            (MethodFunction::Get, MethodObject::ScheduledReportSettings) => match seq.next_element() {
+                Ok(Some(value)) => RequestMethod::Get(GetRequestMethod::ScheduledReportSettings(value)),
+                Err(err) => RequestMethod::invalid(err),
+                Ok(None) => {
+                    return Err(de::Error::invalid_length(1, &self));
+                }
+            },
+            (MethodFunction::Set, MethodObject::ScheduledReportSettings) => match seq.next_element() {
+                Ok(Some(value)) => RequestMethod::Set(SetRequestMethod::ScheduledReportSettings(value)),
+                Err(err) => RequestMethod::invalid(err),
+                Ok(None) => {
+                    return Err(de::Error::invalid_length(1, &self));
+                }
+            },
             // inbuxa: journaling
             (MethodFunction::Get, MethodObject::JournalEntry) => match seq.next_element() {
                 Ok(Some(value)) => RequestMethod::Get(GetRequestMethod::JournalEntry(value)),

crates/jmap-proto/src/response/mod.rs

@@ -115,6 +115,8 @@ pub enum GetResponseMethod {
     SecurityAcceptance(GetResponse<crate::object::inbuxa_security_acceptance::SecurityAcceptance>),
     DeliverabilityReport(GetResponse<crate::object::inbuxa_deliverability_report::DeliverabilityReport>),
     DeliverabilitySettings(GetResponse<crate::object::inbuxa_deliverability_settings::DeliverabilitySettings>),
+    ScheduledReport(GetResponse<crate::object::inbuxa_scheduled_report::ScheduledReport>),
+    ScheduledReportSettings(GetResponse<crate::object::inbuxa_scheduled_report_settings::ScheduledReportSettings>),
     Journal(GetResponse<crate::object::inbuxa_journal::Journal>),
     JournalEntry(GetResponse<crate::object::inbuxa_journal_entry::JournalEntry>),
     HeldMessage(GetResponse<crate::object::inbuxa_held_message::HeldMessage>),
@@ -163,6 +165,8 @@ pub enum SetResponseMethod {
     ),
     DeliverabilityReport(Box<SetResponse<crate::object::inbuxa_deliverability_report::DeliverabilityReport>>),
     DeliverabilitySettings(Box<SetResponse<crate::object::inbuxa_deliverability_settings::DeliverabilitySettings>>),
+    ScheduledReport(Box<SetResponse<crate::object::inbuxa_scheduled_report::ScheduledReport>>),
+    ScheduledReportSettings(Box<SetResponse<crate::object::inbuxa_scheduled_report_settings::ScheduledReportSettings>>),
     Journal(Box<SetResponse<crate::object::inbuxa_journal::Journal>>),
     JournalExport(Box<SetResponse<crate::object::inbuxa_journal_entry::JournalExport>>),
     JournalVerification(Box<SetResponse<crate::object::inbuxa_journal_entry::JournalVerification>>),
@@ -892,6 +896,28 @@ impl<'x> From<SetResponse<crate::object::inbuxa_deliverability_settings::Deliver
         ResponseMethod::Set(SetResponseMethod::DeliverabilitySettings(Box::new(value)))
     }
 }
+impl<'x> From<GetResponse<crate::object::inbuxa_scheduled_report::ScheduledReport>> for ResponseMethod<'x> {
+    fn from(value: GetResponse<crate::object::inbuxa_scheduled_report::ScheduledReport>) -> Self {
+        ResponseMethod::Get(GetResponseMethod::ScheduledReport(value))
+    }
+}
+
+impl<'x> From<SetResponse<crate::object::inbuxa_scheduled_report::ScheduledReport>> for ResponseMethod<'x> {
+    fn from(value: SetResponse<crate::object::inbuxa_scheduled_report::ScheduledReport>) -> Self {
+        ResponseMethod::Set(SetResponseMethod::ScheduledReport(Box::new(value)))
+    }
+}
+impl<'x> From<GetResponse<crate::object::inbuxa_scheduled_report_settings::ScheduledReportSettings>> for ResponseMethod<'x> {
+    fn from(value: GetResponse<crate::object::inbuxa_scheduled_report_settings::ScheduledReportSettings>) -> Self {
+        ResponseMethod::Get(GetResponseMethod::ScheduledReportSettings(value))
+    }
+}
+
+impl<'x> From<SetResponse<crate::object::inbuxa_scheduled_report_settings::ScheduledReportSettings>> for ResponseMethod<'x> {
+    fn from(value: SetResponse<crate::object::inbuxa_scheduled_report_settings::ScheduledReportSettings>) -> Self {
+        ResponseMethod::Set(SetResponseMethod::ScheduledReportSettings(Box::new(value)))
+    }
+}
 
 // inbuxa: accepted security to-do items
 impl<'x> From<GetResponse<crate::object::inbuxa_security_acceptance::SecurityAcceptance>>