lib

commit a32e0e58ade2811dcd6af541f3cf87317fbb75e4
parent 828148e2a15582972063020f37c8962db795537c
Author: triesap <tyson@radroots.org>
Date:   Thu, 30 Jul 2026 23:35:01 +0000

transport: document public api contract

- Publish the final transport host-SPI, target, outcome, and side-effect contract.
- Include crate-level and public-module documentation with a compiling host example.
- Record the reviewed full-feature Rust public API baseline and package index entry.
- Enforce documentation completeness and baseline coverage in package-boundary tests.

Diffstat:
M
crates/transport/README.md
 | 
157
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++----
A
crates/transport/examples/host_transport.rs
 | 
58
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
M
crates/transport/src/error.rs
 | 
2
++
M
crates/transport/src/lib.rs
 | 
1
+
M
crates/transport/src/target.rs
 | 
2
++
M
crates/transport/tests/package_boundary.rs
 | 
75
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
M
docs/api/README.md
 | 
1
+
A
docs/api/radroots_transport.txt
 | 
832
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

8 files changed, 1119 insertions(+), 9 deletions(-)
diff --git a/crates/transport/README.md b/crates/transport/README.md
@@ -1,15 +1,156 @@
 # radroots_transport
 
-This is the README for `radroots_transport`, which provides transport-neutral
-delivery models for the `radroots` core libraries.
+`radroots_transport` is the transport-neutral host SPI for moving verified
+Radroots events between explicit targets. It owns extensible transport and
+target identities, separate source and sink capabilities, bounded fetch and
+delivery requests, provenance, partial outcomes, and normalized errors.
 
-## Overview
+The crate is `no_std` with `alloc`. It does not own network clients, storage,
+outbox claiming, retry loops, schedulers, timers, or fallback policy. Concrete
+adapters such as `radroots_transport_nostr` implement the SPI; applications
+compose those adapters in `radroots_sdk` or their own host layer.
 
- * transport kind, implementation state, and status model types;
- * target URI, target fingerprint, target set, request, and receipt contracts;
- * deterministic target fingerprints based on transport kind and canonical
-   target URI;
- * portable shared models with optional `serde` support.
+The authoritative package charter is the
+[`radroots_transport` section of the Release V1 specification](https://github.com/radrootslabs/lib/blob/master/docs/specs/radroots_crates_release_v1.md#9-radroots_transport).
+
+## Typical flow
+
+1. A host selects a validated [`TransportId`] and constructs one or more
+   canonical [`Target`] values.
+2. [`TargetSet`] rejects an empty, oversized, or duplicate-fingerprint set.
+3. The caller creates a bounded [`FetchRequest`] or [`DeliveryRequest`] with a
+   request identity and absolute deadline.
+4. A dyn-compatible [`EventSource`] or [`EventSink`] implementation performs
+   only the requested operation.
+5. The caller validates [`FetchPage`] or [`DeliveryReceipt`] against the
+   originating request and decides whether normalized retryable outcomes merit
+   another explicit operation.
+
+[`TransportId`]: crate::TransportId
+[`Target`]: crate::Target
+[`TargetSet`]: crate::TargetSet
+[`FetchRequest`]: crate::FetchRequest
+[`DeliveryRequest`]: crate::DeliveryRequest
+[`EventSource`]: crate::EventSource
+[`EventSink`]: crate::EventSink
+[`FetchPage`]: crate::FetchPage
+[`DeliveryReceipt`]: crate::DeliveryReceipt
+
+```rust
+use radroots_transport::{Error, Target, TargetSet, TransportId};
+
+let transport_id = TransportId::parse("example")?;
+let target = Target::new(transport_id, "https://transport.example/events")?;
+let targets = TargetSet::new(vec![target])?;
+
+assert_eq!(targets.len(), 1);
+# Ok::<(), Error>(())
+```
+
+The complete externally implementable SPI example is
+[`examples/host_transport.rs`](examples/host_transport.rs).
+
+## Host SPI contract
+
+`EventSource` and `EventSink` are independent, externally implementable,
+dyn-compatible `Send + Sync` traits. An adapter may implement either or both.
+Their methods return boxed `Future + Send` values so this package does not
+select an async runtime or require an async-trait macro.
+
+- `status` is observational and must not begin fetch or delivery work.
+- `fetch` returns one bounded page plus per-target outcomes and explicit
+  continuation state.
+- `deliver` returns one receipt for the exact request and every requested
+  target; it never performs an implicit retry.
+- Implementations must not install an executor or spawn hidden workers. The
+  composing host owns polling, scheduling, retries, and process lifecycle.
+- Concrete backend failures are normalized to `radroots_transport::Error`.
+  Native sources may be retained by adapters, but public outcome codes and
+  messages must remain bounded and secret-safe.
+
+## Targets and extensible identity
+
+`TransportId` is a validated open identity, not a closed enum. The built-in
+`LOCAL`, `NOSTR`, `RETICULUM`, and `RADROOTSD` constants are conveniences;
+future adapters can use validated custom IDs without changing this crate.
+
+Targets contain a transport ID, canonical endpoint URI, optional scope and
+human label, and a derived SHA-256 fingerprint. The label is descriptive and
+does not participate in identity. The transport ID, endpoint, and scope do.
+Target-set construction preserves caller order and rejects duplicate
+fingerprints instead of silently deduplicating them.
+
+Adapter-specific endpoint policy belongs in the adapter. This generic package
+does not export relay URL types, Reticulum constants, network clients, or
+private-network exceptions.
+
+## Bounds, deadlines, cancellation, and commit points
+
+Request IDs, endpoint values, cursors, target sets, outcome details, and page
+sizes are bounded by public constants. Fetch and delivery requests carry an
+absolute Unix-millisecond deadline; constructors validate the deadline but do
+not read a clock.
+
+Dropping a returned future requests cancellation. Before an adapter publishes
+or commits a remote operation, cancellation must leave no durable effect.
+After that boundary, cancellation does not imply rollback: the adapter must
+preserve and report the final remote state when it can be observed. Each
+concrete adapter documents its exact publication or commit point.
+
+## Outcomes, partial success, and retry
+
+Fetch pages and delivery receipts preserve target-local results. Delivery
+satisfaction is explicit (`any`, `all`, quorum, or required fingerprints) and
+is evaluated against the originating request. Retryability and terminality are
+normalized data on outcomes, never an automatic loop. Authentication,
+unavailability, rejection, cancellation, partial progress, and unknown remote
+state must not be rewritten as success or silent fallback.
+
+## Serialization and provenance
+
+With `serde`, passive identities, requests, pages, receipts, status values, and
+outcomes use validated representations. Deserialization rechecks canonical
+identity, bounds, request/receipt cardinality, and provenance rather than
+trusting serialized fingerprints or counts.
+
+Inbound events carry the transport ID, exact target fingerprint, observation
+time, and optional continuation cursor that produced them. A page cannot claim
+events or outcomes for targets outside its request.
+
+## Security and side effects
+
+- Target endpoint syntax is validated before an adapter receives a request;
+  adapters remain responsible for scheme, DNS/IP, TLS, and private-network
+  policy before connection.
+- Delivery accepts a validated signed event, not arbitrary bytes.
+- Receipt and page constructors reject missing, duplicate, unexpected, or
+  forged target evidence.
+- This crate forbids unsafe code and contains no socket, filesystem, database,
+  global state, timer, executor, or retry implementation.
+- No transport may silently route through another transport.
+
+## Features
+
+| Feature | Default | Contract |
+| --- | --- | --- |
+| `std` | yes | Enables standard-library support in canonical dependency values; it adds no I/O, runtime, or global initialization. |
+| `serde` | yes | Adds validated serialization for passive identities, requests, status, provenance, pages, receipts, policies, and outcomes. |
+
+Features are additive. `--no-default-features` provides the `no_std + alloc`
+core, and `serde` is supported independently of `std`.
+
+## Intended consumers
+
+- `radroots_transport_nostr` provides the concrete native Nostr adapter.
+- `radroots_storage` persists transport-neutral outbox and evidence values.
+- `radroots_sync` plans bounded operations and applies explicit retry policy.
+- `radroots_sdk` composes storage, signing, source, and sink implementations.
+- Service and future adapter hosts implement one or both SPIs and own runtime,
+  network, cancellation, and lifecycle behavior.
+
+Applications that only need ordinary Radroots operations should normally use
+`radroots` or `radroots_sdk`; implement this package directly when providing a
+new transport adapter or advanced host composition.
 
 ## Copyright
 
diff --git a/crates/transport/examples/host_transport.rs b/crates/transport/examples/host_transport.rs
@@ -0,0 +1,58 @@
+use radroots_transport::{
+    DeliveryReceipt, DeliveryRequest, Error, EventSink, EventSource, FetchPage, FetchRequest,
+    TransportId,
+    capability::{Availability, Maturity, SinkCapabilities, SourceCapabilities},
+    sink::SinkStatus,
+    source::{BoxFuture, SourceStatus},
+};
+
+struct HostTransport;
+
+impl EventSource for HostTransport {
+    fn status(&self) -> BoxFuture<'_, Result<SourceStatus, Error>> {
+        Box::pin(async {
+            Ok(SourceStatus::new(
+                TransportId::LOCAL,
+                true,
+                Maturity::Preview,
+                Availability::Unavailable,
+                SourceCapabilities::NONE,
+                "host source is not connected",
+            ))
+        })
+    }
+
+    fn fetch(&self, _request: FetchRequest) -> BoxFuture<'_, Result<FetchPage, Error>> {
+        Box::pin(async { Err(Error::UnsupportedOperation) })
+    }
+}
+
+impl EventSink for HostTransport {
+    fn status(&self) -> BoxFuture<'_, Result<SinkStatus, Error>> {
+        Box::pin(async {
+            Ok(SinkStatus::new(
+                TransportId::LOCAL,
+                true,
+                Maturity::Preview,
+                Availability::Unavailable,
+                SinkCapabilities::NONE,
+                "host sink is not connected",
+            ))
+        })
+    }
+
+    fn deliver(&self, _request: DeliveryRequest) -> BoxFuture<'_, Result<DeliveryReceipt, Error>> {
+        Box::pin(async { Err(Error::UnsupportedOperation) })
+    }
+}
+
+fn main() {
+    let transport = HostTransport;
+    let source: &dyn EventSource = &transport;
+    let sink: &dyn EventSink = &transport;
+
+    let future = source.status();
+    drop(future); // The composing host chooses and drives its async executor.
+    let future = sink.status();
+    drop(future);
+}
diff --git a/crates/transport/src/error.rs b/crates/transport/src/error.rs
@@ -1,3 +1,5 @@
+//! Normalized transport contract errors.
+
 use core::fmt;
 
 /// Transport contract failure.
diff --git a/crates/transport/src/lib.rs b/crates/transport/src/lib.rs
@@ -1,3 +1,4 @@
+#![doc = include_str!("../README.md")]
 #![cfg_attr(not(feature = "std"), no_std)]
 #![forbid(unsafe_code)]
 #![cfg_attr(coverage_nightly, feature(coverage_attribute))]
diff --git a/crates/transport/src/target.rs b/crates/transport/src/target.rs
@@ -1,3 +1,5 @@
+//! Extensible transport identities and canonical operation targets.
+
 use crate::{
     RadrootsTransportError, RadrootsTransportKind,
     endpoint::{ENDPOINT_URI_MAX_BYTES, TARGET_LABEL_MAX_BYTES, TARGET_SCOPE_MAX_BYTES},
diff --git a/crates/transport/tests/package_boundary.rs b/crates/transport/tests/package_boundary.rs
@@ -1,4 +1,4 @@
-use std::collections::BTreeSet;
+use std::{collections::BTreeSet, fs, path::Path};
 
 #[allow(unused_imports)]
 use radroots_transport::{
@@ -9,6 +9,9 @@ use radroots_transport::{
 };
 
 const MANIFEST: &str = include_str!("../Cargo.toml");
+const EXAMPLE: &str = include_str!("../examples/host_transport.rs");
+const PUBLIC_API: &str = include_str!("../../../docs/api/radroots_transport.txt");
+const README: &str = include_str!("../README.md");
 const ROOT: &str = include_str!("../src/lib.rs");
 const SOURCE: &str = include_str!("../src/source.rs");
 const SINK: &str = include_str!("../src/sink.rs");
@@ -48,6 +51,7 @@ fn manifest_has_final_identity_features_and_required_radroots_dependencies() {
 
 #[test]
 fn crate_root_declares_the_approved_public_module_skeleton() {
+    assert!(ROOT.contains("#![doc = include_str!(\"../README.md\")]"));
     assert!(ROOT.contains("#![cfg_attr(not(feature = \"std\"), no_std)]"));
     assert_eq!(
         root_declarations("pub mod "),
@@ -65,6 +69,75 @@ fn crate_root_declares_the_approved_public_module_skeleton() {
 }
 
 #[test]
+fn package_documentation_and_reviewed_api_baseline_are_complete() {
+    for required in [
+        "## Typical flow",
+        "## Host SPI contract",
+        "## Targets and extensible identity",
+        "## Bounds, deadlines, cancellation, and commit points",
+        "## Outcomes, partial success, and retry",
+        "## Serialization and provenance",
+        "## Security and side effects",
+        "## Features",
+        "## Intended consumers",
+        "radroots_crates_release_v1.md#9-radroots_transport",
+        "examples/host_transport.rs",
+    ] {
+        assert!(README.contains(required), "README is missing {required}");
+    }
+    for required in [
+        "impl EventSource for HostTransport",
+        "impl EventSink for HostTransport",
+        "fn fetch(&self, _request: FetchRequest) -> BoxFuture",
+        "_request: DeliveryRequest",
+        "let source: &dyn EventSource",
+        "let sink: &dyn EventSink",
+        "drop(future)",
+    ] {
+        assert!(EXAMPLE.contains(required), "example is missing {required}");
+    }
+    for required in [
+        "pub mod radroots_transport::capability",
+        "pub mod radroots_transport::endpoint",
+        "pub mod radroots_transport::error",
+        "pub mod radroots_transport::outcome",
+        "pub mod radroots_transport::policy",
+        "pub mod radroots_transport::sink",
+        "pub mod radroots_transport::source",
+        "pub mod radroots_transport::target",
+        "pub trait radroots_transport::EventSource",
+        "pub trait radroots_transport::EventSink",
+    ] {
+        assert!(
+            PUBLIC_API.contains(required),
+            "public API baseline is missing {required}"
+        );
+    }
+}
+
+#[test]
+fn every_public_module_has_crate_level_documentation() {
+    let source_root = Path::new(env!("CARGO_MANIFEST_DIR")).join("src");
+    for module in [
+        "capability",
+        "endpoint",
+        "error",
+        "outcome",
+        "policy",
+        "sink",
+        "source",
+        "target",
+    ] {
+        let path = source_root.join(format!("{module}.rs"));
+        let source = fs::read_to_string(&path).expect("read module source");
+        assert!(
+            source.starts_with("//! "),
+            "public module {module} must start with module documentation"
+        );
+    }
+}
+
+#[test]
 fn source_and_sink_are_independent_dyn_compatible_host_spis() {
     for required in [
         "pub trait EventSource: Send + Sync",
diff --git a/docs/api/README.md b/docs/api/README.md
@@ -38,3 +38,4 @@ expand a package beyond its charter.
 | `radroots_event_codec` | [`radroots_event_codec.txt`](radroots_event_codec.txt) | [release V1 specification](../specs/radroots_crates_release_v1.md) |
 | `radroots_trade` | [`radroots_trade.txt`](radroots_trade.txt) | [release V1 specification](../specs/radroots_crates_release_v1.md) |
 | `radroots_signing` | [`radroots_signing.txt`](radroots_signing.txt) | [release V1 specification](../specs/radroots_crates_release_v1.md) |
+| `radroots_transport` | [`radroots_transport.txt`](radroots_transport.txt) | [release V1 specification](../specs/radroots_crates_release_v1.md) |
diff --git a/docs/api/radroots_transport.txt b/docs/api/radroots_transport.txt
@@ -0,0 +1,832 @@
+pub mod radroots_transport
+pub mod radroots_transport::capability
+pub enum radroots_transport::capability::Availability
+pub radroots_transport::capability::Availability::Available
+pub radroots_transport::capability::Availability::Degraded
+pub radroots_transport::capability::Availability::Unavailable
+impl core::convert::From<radroots_protocol::capability::v1::Availability> for radroots_transport::capability::Availability
+pub fn radroots_transport::capability::Availability::from(radroots_protocol::capability::v1::Availability) -> Self
+impl core::convert::From<radroots_transport::capability::Availability> for radroots_protocol::capability::v1::Availability
+pub fn radroots_protocol::capability::v1::Availability::from(radroots_transport::capability::Availability) -> Self
+pub enum radroots_transport::capability::Maturity
+pub radroots_transport::capability::Maturity::Experimental
+pub radroots_transport::capability::Maturity::Preview
+pub radroots_transport::capability::Maturity::Stable
+impl core::convert::From<radroots_protocol::capability::v1::Maturity> for radroots_transport::capability::Maturity
+pub fn radroots_transport::capability::Maturity::from(radroots_protocol::capability::v1::Maturity) -> Self
+impl core::convert::From<radroots_transport::capability::Maturity> for radroots_protocol::capability::v1::Maturity
+pub fn radroots_protocol::capability::v1::Maturity::from(radroots_transport::capability::Maturity) -> Self
+pub struct radroots_transport::capability::SinkCapabilities
+impl radroots_transport::capability::SinkCapabilities
+pub const radroots_transport::capability::SinkCapabilities::DELIVER: Self
+pub const radroots_transport::capability::SinkCapabilities::NONE: Self
+pub const fn radroots_transport::capability::SinkCapabilities::can_deliver(self) -> bool
+pub const fn radroots_transport::capability::SinkCapabilities::can_gateway_forward(self) -> bool
+pub const fn radroots_transport::capability::SinkCapabilities::can_observe_receipts(self) -> bool
+pub const fn radroots_transport::capability::SinkCapabilities::with_gateway_forwarding(self, bool) -> Self
+pub const fn radroots_transport::capability::SinkCapabilities::with_receipt_observation(self, bool) -> Self
+impl core::convert::From<&radroots_protocol::capability::v1::TransportDescriptor> for radroots_transport::capability::SinkCapabilities
+pub fn radroots_transport::capability::SinkCapabilities::from(&radroots_protocol::capability::v1::TransportDescriptor) -> Self
+pub struct radroots_transport::capability::SourceCapabilities
+impl radroots_transport::capability::SourceCapabilities
+pub const radroots_transport::capability::SourceCapabilities::FETCH: Self
+pub const radroots_transport::capability::SourceCapabilities::NONE: Self
+pub const fn radroots_transport::capability::SourceCapabilities::can_discover(self) -> bool
+pub const fn radroots_transport::capability::SourceCapabilities::can_fetch(self) -> bool
+pub const fn radroots_transport::capability::SourceCapabilities::with_discovery(self, bool) -> Self
+impl core::convert::From<&radroots_protocol::capability::v1::TransportDescriptor> for radroots_transport::capability::SourceCapabilities
+pub fn radroots_transport::capability::SourceCapabilities::from(&radroots_protocol::capability::v1::TransportDescriptor) -> Self
+pub mod radroots_transport::endpoint
+pub struct radroots_transport::endpoint::EndpointUri(_)
+impl radroots_transport::target::EndpointUri
+pub fn radroots_transport::target::EndpointUri::as_str(&self) -> &str
+pub fn radroots_transport::target::EndpointUri::parse(impl core::convert::AsRef<str>) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+impl core::convert::AsRef<str> for radroots_transport::target::EndpointUri
+pub fn radroots_transport::target::EndpointUri::as_ref(&self) -> &str
+impl core::convert::TryFrom<&str> for radroots_transport::target::EndpointUri
+pub type radroots_transport::target::EndpointUri::Error = radroots_transport::error::RadrootsTransportError
+pub fn radroots_transport::target::EndpointUri::try_from(&str) -> core::result::Result<Self, Self::Error>
+impl core::fmt::Display for radroots_transport::target::EndpointUri
+pub fn radroots_transport::target::EndpointUri::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl core::str::traits::FromStr for radroots_transport::target::EndpointUri
+pub type radroots_transport::target::EndpointUri::Err = radroots_transport::error::RadrootsTransportError
+pub fn radroots_transport::target::EndpointUri::from_str(&str) -> core::result::Result<Self, Self::Err>
+impl<'de> serde_core::de::Deserialize<'de> for radroots_transport::target::EndpointUri
+pub fn radroots_transport::target::EndpointUri::deserialize<D>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> where D: serde_core::de::Deserializer<'de>
+pub struct radroots_transport::endpoint::TargetLabel(_)
+impl radroots_transport::target::TargetLabel
+pub fn radroots_transport::target::TargetLabel::as_str(&self) -> &str
+pub fn radroots_transport::target::TargetLabel::parse(impl core::convert::AsRef<str>) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+impl core::convert::AsRef<str> for radroots_transport::target::TargetLabel
+pub fn radroots_transport::target::TargetLabel::as_ref(&self) -> &str
+impl core::convert::TryFrom<&str> for radroots_transport::target::TargetLabel
+pub type radroots_transport::target::TargetLabel::Error = radroots_transport::error::RadrootsTransportError
+pub fn radroots_transport::target::TargetLabel::try_from(&str) -> core::result::Result<Self, Self::Error>
+impl core::fmt::Display for radroots_transport::target::TargetLabel
+pub fn radroots_transport::target::TargetLabel::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl core::str::traits::FromStr for radroots_transport::target::TargetLabel
+pub type radroots_transport::target::TargetLabel::Err = radroots_transport::error::RadrootsTransportError
+pub fn radroots_transport::target::TargetLabel::from_str(&str) -> core::result::Result<Self, Self::Err>
+impl<'de> serde_core::de::Deserialize<'de> for radroots_transport::target::TargetLabel
+pub fn radroots_transport::target::TargetLabel::deserialize<D>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> where D: serde_core::de::Deserializer<'de>
+pub struct radroots_transport::endpoint::TargetScope(_)
+impl radroots_transport::target::TargetScope
+pub fn radroots_transport::target::TargetScope::as_str(&self) -> &str
+pub fn radroots_transport::target::TargetScope::local_reticulum() -> Self
+pub fn radroots_transport::target::TargetScope::parse(impl core::convert::AsRef<str>) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+impl core::convert::AsRef<str> for radroots_transport::target::TargetScope
+pub fn radroots_transport::target::TargetScope::as_ref(&self) -> &str
+impl core::convert::TryFrom<&str> for radroots_transport::target::TargetScope
+pub type radroots_transport::target::TargetScope::Error = radroots_transport::error::RadrootsTransportError
+pub fn radroots_transport::target::TargetScope::try_from(&str) -> core::result::Result<Self, Self::Error>
+impl core::fmt::Display for radroots_transport::target::TargetScope
+pub fn radroots_transport::target::TargetScope::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl core::str::traits::FromStr for radroots_transport::target::TargetScope
+pub type radroots_transport::target::TargetScope::Err = radroots_transport::error::RadrootsTransportError
+pub fn radroots_transport::target::TargetScope::from_str(&str) -> core::result::Result<Self, Self::Err>
+impl<'de> serde_core::de::Deserialize<'de> for radroots_transport::target::TargetScope
+pub fn radroots_transport::target::TargetScope::deserialize<D>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> where D: serde_core::de::Deserializer<'de>
+pub const radroots_transport::endpoint::ENDPOINT_URI_MAX_BYTES: usize
+pub const radroots_transport::endpoint::TARGET_LABEL_MAX_BYTES: usize
+pub const radroots_transport::endpoint::TARGET_SCOPE_MAX_BYTES: usize
+pub mod radroots_transport::error
+pub enum radroots_transport::error::RadrootsTransportError
+pub radroots_transport::error::RadrootsTransportError::DeliveryReceiptRequestIdMismatch
+pub radroots_transport::error::RadrootsTransportError::DeliveryReceiptTargetSetMismatch
+pub radroots_transport::error::RadrootsTransportError::DeliveryTargetReceiptAttemptMismatch
+pub radroots_transport::error::RadrootsTransportError::DeliveryTargetReceiptStatusMismatch
+pub radroots_transport::error::RadrootsTransportError::DuplicateDeliveryTargetReceipt
+pub radroots_transport::error::RadrootsTransportError::DuplicateFetchTargetOutcome
+pub radroots_transport::error::RadrootsTransportError::DuplicateRequiredTargetFingerprint
+pub radroots_transport::error::RadrootsTransportError::DuplicateTargetFingerprint
+pub radroots_transport::error::RadrootsTransportError::EmptyDeliveryRequestId
+pub radroots_transport::error::RadrootsTransportError::EmptyFetchCursor
+pub radroots_transport::error::RadrootsTransportError::EmptyFetchRequestId
+pub radroots_transport::error::RadrootsTransportError::EmptyPayloadBytes
+pub radroots_transport::error::RadrootsTransportError::EmptyPayloadId
+pub radroots_transport::error::RadrootsTransportError::EmptyPayloadLabel
+pub radroots_transport::error::RadrootsTransportError::EmptyRequiredTargetSet
+pub radroots_transport::error::RadrootsTransportError::EmptyTargetLabel
+pub radroots_transport::error::RadrootsTransportError::EmptyTargetScope
+pub radroots_transport::error::RadrootsTransportError::EmptyTargetSet
+pub radroots_transport::error::RadrootsTransportError::EmptyTargetUri
+pub radroots_transport::error::RadrootsTransportError::EmptyTransportKind
+pub radroots_transport::error::RadrootsTransportError::FetchPageLimitExceeded
+pub radroots_transport::error::RadrootsTransportError::FetchPageRequestMismatch
+pub radroots_transport::error::RadrootsTransportError::InvalidDeliveryDeadline
+pub radroots_transport::error::RadrootsTransportError::InvalidDeliveryOutcome
+pub radroots_transport::error::RadrootsTransportError::InvalidDeliveryRequestId
+pub radroots_transport::error::RadrootsTransportError::InvalidDeliveryTimestamp
+pub radroots_transport::error::RadrootsTransportError::InvalidFetchCursor
+pub radroots_transport::error::RadrootsTransportError::InvalidFetchDeadline
+pub radroots_transport::error::RadrootsTransportError::InvalidFetchLimit
+pub radroots_transport::error::RadrootsTransportError::InvalidFetchRequestId
+pub radroots_transport::error::RadrootsTransportError::InvalidObservedAt
+pub radroots_transport::error::RadrootsTransportError::InvalidPayloadBytes
+pub radroots_transport::error::RadrootsTransportError::InvalidPayloadDigest
+pub radroots_transport::error::RadrootsTransportError::InvalidPayloadId
+pub radroots_transport::error::RadrootsTransportError::InvalidPayloadLabel
+pub radroots_transport::error::RadrootsTransportError::InvalidSatisfactionPolicy
+pub radroots_transport::error::RadrootsTransportError::InvalidTargetFingerprint
+pub radroots_transport::error::RadrootsTransportError::InvalidTargetLabel
+pub radroots_transport::error::RadrootsTransportError::InvalidTargetScope
+pub radroots_transport::error::RadrootsTransportError::InvalidTargetUri
+pub radroots_transport::error::RadrootsTransportError::InvalidTransportKind
+pub radroots_transport::error::RadrootsTransportError::MissingDeliveryTargetReceipt
+pub radroots_transport::error::RadrootsTransportError::PayloadDigestMismatch
+pub radroots_transport::error::RadrootsTransportError::RequiredTargetNotRequested
+pub radroots_transport::error::RadrootsTransportError::TargetSetTooLarge
+pub radroots_transport::error::RadrootsTransportError::TransportOutcomeStatusMismatch
+pub radroots_transport::error::RadrootsTransportError::UnexpectedDeliveryTargetReceipt
+pub radroots_transport::error::RadrootsTransportError::UnexpectedFetchProvenance
+pub radroots_transport::error::RadrootsTransportError::UnexpectedFetchTargetOutcome
+pub radroots_transport::error::RadrootsTransportError::UnsupportedOperation
+impl core::fmt::Display for radroots_transport::error::RadrootsTransportError
+pub fn radroots_transport::error::RadrootsTransportError::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub type radroots_transport::error::Error = radroots_transport::error::RadrootsTransportError
+pub mod radroots_transport::outcome
+pub enum radroots_transport::outcome::DeliveryOutcomeKind
+pub radroots_transport::outcome::DeliveryOutcomeKind::Accepted
+pub radroots_transport::outcome::DeliveryOutcomeKind::Delivered
+pub radroots_transport::outcome::DeliveryOutcomeKind::Failed
+pub radroots_transport::outcome::DeliveryOutcomeKind::Rejected
+pub radroots_transport::outcome::DeliveryOutcomeKind::Unavailable
+pub enum radroots_transport::outcome::FetchTargetState
+pub radroots_transport::outcome::FetchTargetState::Cancelled
+pub radroots_transport::outcome::FetchTargetState::Complete
+pub radroots_transport::outcome::FetchTargetState::FailedRetryable
+pub radroots_transport::outcome::FetchTargetState::FailedTerminal
+pub radroots_transport::outcome::FetchTargetState::Partial
+pub radroots_transport::outcome::FetchTargetState::Unavailable
+impl radroots_transport::outcome::FetchTargetState
+pub const fn radroots_transport::outcome::FetchTargetState::is_retryable(self) -> bool
+pub const fn radroots_transport::outcome::FetchTargetState::is_terminal(self) -> bool
+pub enum radroots_transport::outcome::Retryability
+pub radroots_transport::outcome::Retryability::NotApplicable
+pub radroots_transport::outcome::Retryability::Retryable
+pub radroots_transport::outcome::Retryability::Terminal
+pub struct radroots_transport::outcome::DeliveryOutcome
+impl radroots_transport::outcome::DeliveryOutcome
+pub const fn radroots_transport::outcome::DeliveryOutcome::accepted() -> Self
+pub fn radroots_transport::outcome::DeliveryOutcome::code(&self) -> core::option::Option<&str>
+pub const fn radroots_transport::outcome::DeliveryOutcome::delivered() -> Self
+pub const fn radroots_transport::outcome::DeliveryOutcome::failed(radroots_transport::outcome::Retryability) -> core::result::Result<Self, radroots_transport::error::Error>
+pub const fn radroots_transport::outcome::DeliveryOutcome::is_retryable(&self) -> bool
+pub const fn radroots_transport::outcome::DeliveryOutcome::is_terminal(&self) -> bool
+pub const fn radroots_transport::outcome::DeliveryOutcome::kind(&self) -> radroots_transport::outcome::DeliveryOutcomeKind
+pub fn radroots_transport::outcome::DeliveryOutcome::message(&self) -> core::option::Option<&str>
+pub const fn radroots_transport::outcome::DeliveryOutcome::rejected() -> Self
+pub const fn radroots_transport::outcome::DeliveryOutcome::retryability(&self) -> radroots_transport::outcome::Retryability
+pub const fn radroots_transport::outcome::DeliveryOutcome::satisfies(&self, radroots_transport::policy::SatisfactionClass) -> bool
+pub const fn radroots_transport::outcome::DeliveryOutcome::unavailable() -> Self
+pub fn radroots_transport::outcome::DeliveryOutcome::with_detail(self, impl core::convert::Into<alloc::string::String>, impl core::convert::Into<alloc::string::String>) -> core::result::Result<Self, radroots_transport::error::Error>
+impl<'de> serde_core::de::Deserialize<'de> for radroots_transport::outcome::DeliveryOutcome
+pub fn radroots_transport::outcome::DeliveryOutcome::deserialize<D>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> where D: serde_core::de::Deserializer<'de>
+pub struct radroots_transport::outcome::FetchTargetOutcome
+impl radroots_transport::outcome::FetchTargetOutcome
+pub fn radroots_transport::outcome::FetchTargetOutcome::message(&self) -> core::option::Option<&str>
+pub const fn radroots_transport::outcome::FetchTargetOutcome::new(radroots_transport::target::TargetFingerprint, radroots_transport::outcome::FetchTargetState) -> Self
+pub const fn radroots_transport::outcome::FetchTargetOutcome::state(&self) -> radroots_transport::outcome::FetchTargetState
+pub const fn radroots_transport::outcome::FetchTargetOutcome::target(&self) -> &radroots_transport::target::TargetFingerprint
+pub fn radroots_transport::outcome::FetchTargetOutcome::with_message(self, impl core::convert::Into<alloc::string::String>) -> Self
+pub const radroots_transport::outcome::DELIVERY_OUTCOME_CODE_MAX_BYTES: usize
+pub const radroots_transport::outcome::DELIVERY_OUTCOME_MESSAGE_MAX_BYTES: usize
+pub mod radroots_transport::policy
+pub enum radroots_transport::policy::SatisfactionClass
+pub radroots_transport::policy::SatisfactionClass::Accepted
+pub radroots_transport::policy::SatisfactionClass::Delivered
+pub struct radroots_transport::policy::SatisfactionPolicy
+impl radroots_transport::policy::SatisfactionPolicy
+pub const fn radroots_transport::policy::SatisfactionPolicy::class(&self) -> radroots_transport::policy::SatisfactionClass
+pub const fn radroots_transport::policy::SatisfactionPolicy::new(radroots_transport::policy::SatisfactionClass, radroots_transport::policy::TargetPolicy) -> Self
+pub const fn radroots_transport::policy::SatisfactionPolicy::targets(&self) -> &radroots_transport::policy::TargetPolicy
+pub struct radroots_transport::policy::TargetPolicy
+impl radroots_transport::policy::TargetPolicy
+pub const fn radroots_transport::policy::TargetPolicy::all() -> Self
+pub const fn radroots_transport::policy::TargetPolicy::any() -> Self
+pub const fn radroots_transport::policy::TargetPolicy::quorum(u16) -> core::result::Result<Self, radroots_transport::error::Error>
+pub fn radroots_transport::policy::TargetPolicy::required(alloc::vec::Vec<radroots_transport::target::TargetFingerprint>) -> core::result::Result<Self, radroots_transport::error::Error>
+pub fn radroots_transport::policy::TargetPolicy::required_targets(&self) -> core::option::Option<&[radroots_transport::target::TargetFingerprint]>
+impl<'de> serde_core::de::Deserialize<'de> for radroots_transport::policy::TargetPolicy
+pub fn radroots_transport::policy::TargetPolicy::deserialize<D>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> where D: serde_core::de::Deserializer<'de>
+pub mod radroots_transport::sink
+pub struct radroots_transport::sink::DeliveryPayload
+impl radroots_transport::sink::DeliveryPayload
+pub const fn radroots_transport::sink::DeliveryPayload::event(&self) -> &radroots_event::draft::SignedEvent
+pub const fn radroots_transport::sink::DeliveryPayload::new(radroots_event::draft::SignedEvent) -> Self
+pub struct radroots_transport::sink::DeliveryReceipt
+impl radroots_transport::sink::DeliveryReceipt
+pub fn radroots_transport::sink::DeliveryReceipt::for_request(&radroots_transport::sink::DeliveryRequest, alloc::vec::Vec<radroots_transport::sink::DeliveryTargetReceipt>) -> core::result::Result<Self, radroots_transport::error::Error>
+pub fn radroots_transport::sink::DeliveryReceipt::is_satisfied(&self, &radroots_transport::sink::DeliveryRequest) -> core::result::Result<bool, radroots_transport::error::Error>
+pub const fn radroots_transport::sink::DeliveryReceipt::request_id(&self) -> &radroots_transport::sink::DeliveryRequestId
+pub fn radroots_transport::sink::DeliveryReceipt::target_receipts(&self) -> &[radroots_transport::sink::DeliveryTargetReceipt]
+pub fn radroots_transport::sink::DeliveryReceipt::validate_for_request(&self, &radroots_transport::sink::DeliveryRequest) -> core::result::Result<(), radroots_transport::error::Error>
+impl<'de> serde_core::de::Deserialize<'de> for radroots_transport::sink::DeliveryReceipt
+pub fn radroots_transport::sink::DeliveryReceipt::deserialize<D>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> where D: serde_core::de::Deserializer<'de>
+pub struct radroots_transport::sink::DeliveryRequest
+impl radroots_transport::sink::DeliveryRequest
+pub const fn radroots_transport::sink::DeliveryRequest::deadline_unix_ms(&self) -> u64
+pub fn radroots_transport::sink::DeliveryRequest::new(impl core::convert::Into<alloc::string::String>, radroots_transport::sink::DeliveryPayload, radroots_transport::target::TargetSet, radroots_transport::policy::SatisfactionPolicy, u64) -> core::result::Result<Self, radroots_transport::error::Error>
+pub const fn radroots_transport::sink::DeliveryRequest::payload(&self) -> &radroots_transport::sink::DeliveryPayload
+pub const fn radroots_transport::sink::DeliveryRequest::request_id(&self) -> &radroots_transport::sink::DeliveryRequestId
+pub const fn radroots_transport::sink::DeliveryRequest::satisfaction(&self) -> &radroots_transport::policy::SatisfactionPolicy
+pub const fn radroots_transport::sink::DeliveryRequest::target_set(&self) -> &radroots_transport::target::TargetSet
+impl<'de> serde_core::de::Deserialize<'de> for radroots_transport::sink::DeliveryRequest
+pub fn radroots_transport::sink::DeliveryRequest::deserialize<D>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> where D: serde_core::de::Deserializer<'de>
+pub struct radroots_transport::sink::DeliveryRequestId(_)
+impl radroots_transport::sink::DeliveryRequestId
+pub fn radroots_transport::sink::DeliveryRequestId::as_str(&self) -> &str
+pub fn radroots_transport::sink::DeliveryRequestId::parse(impl core::convert::Into<alloc::string::String>) -> core::result::Result<Self, radroots_transport::error::Error>
+impl serde_core::ser::Serialize for radroots_transport::sink::DeliveryRequestId
+pub fn radroots_transport::sink::DeliveryRequestId::serialize<S>(&self, S) -> core::result::Result<<S as serde_core::ser::Serializer>::Ok, <S as serde_core::ser::Serializer>::Error> where S: serde_core::ser::Serializer
+impl<'de> serde_core::de::Deserialize<'de> for radroots_transport::sink::DeliveryRequestId
+pub fn radroots_transport::sink::DeliveryRequestId::deserialize<D>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> where D: serde_core::de::Deserializer<'de>
+pub struct radroots_transport::sink::DeliveryTargetReceipt
+impl radroots_transport::sink::DeliveryTargetReceipt
+pub const fn radroots_transport::sink::DeliveryTargetReceipt::attempted(radroots_transport::target::Target, radroots_transport::outcome::DeliveryOutcome) -> Self
+pub const fn radroots_transport::sink::DeliveryTargetReceipt::outcome(&self) -> &radroots_transport::outcome::DeliveryOutcome
+pub fn radroots_transport::sink::DeliveryTargetReceipt::skipped(radroots_transport::target::Target, radroots_transport::outcome::DeliveryOutcome) -> core::result::Result<Self, radroots_transport::error::Error>
+pub const fn radroots_transport::sink::DeliveryTargetReceipt::target(&self) -> &radroots_transport::target::Target
+pub const fn radroots_transport::sink::DeliveryTargetReceipt::was_attempted(&self) -> bool
+impl<'de> serde_core::de::Deserialize<'de> for radroots_transport::sink::DeliveryTargetReceipt
+pub fn radroots_transport::sink::DeliveryTargetReceipt::deserialize<D>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> where D: serde_core::de::Deserializer<'de>
+pub struct radroots_transport::sink::SinkStatus
+impl radroots_transport::SinkStatus
+pub const fn radroots_transport::SinkStatus::availability(&self) -> radroots_transport::capability::Availability
+pub const fn radroots_transport::SinkStatus::capabilities(&self) -> radroots_transport::capability::SinkCapabilities
+pub fn radroots_transport::SinkStatus::from_descriptor(&radroots_protocol::capability::v1::TransportDescriptor, bool, impl core::convert::Into<alloc::string::String>) -> Self
+pub const fn radroots_transport::SinkStatus::is_configured(&self) -> bool
+pub const fn radroots_transport::SinkStatus::maturity(&self) -> radroots_transport::capability::Maturity
+pub fn radroots_transport::SinkStatus::message(&self) -> &str
+pub fn radroots_transport::SinkStatus::new(radroots_transport::TransportId, bool, radroots_transport::capability::Maturity, radroots_transport::capability::Availability, radroots_transport::capability::SinkCapabilities, impl core::convert::Into<alloc::string::String>) -> Self
+pub const fn radroots_transport::SinkStatus::transport_id(&self) -> radroots_transport::TransportId
+pub const radroots_transport::sink::DELIVERY_REQUEST_ID_MAX_BYTES: usize
+pub trait radroots_transport::sink::EventSink: core::marker::Send + core::marker::Sync
+pub fn radroots_transport::sink::EventSink::deliver(&self, radroots_transport::sink::DeliveryRequest) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_transport::sink::DeliveryReceipt, radroots_transport::error::Error>>
+pub fn radroots_transport::sink::EventSink::status(&self) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_transport::SinkStatus, radroots_transport::error::Error>>
+pub mod radroots_transport::source
+pub enum radroots_transport::source::NextPage
+pub radroots_transport::source::NextPage::Cancelled
+pub radroots_transport::source::NextPage::Cancelled::resume_from: core::option::Option<radroots_transport::source::FetchCursor>
+pub radroots_transport::source::NextPage::Complete
+pub radroots_transport::source::NextPage::Cursor(radroots_transport::source::FetchCursor)
+pub struct radroots_transport::source::EventProvenance
+impl radroots_transport::source::EventProvenance
+pub const fn radroots_transport::source::EventProvenance::cursor(&self) -> core::option::Option<&radroots_transport::source::FetchCursor>
+pub fn radroots_transport::source::EventProvenance::new(radroots_transport::TransportId, radroots_transport::target::TargetFingerprint, u64) -> core::result::Result<Self, radroots_transport::error::Error>
+pub const fn radroots_transport::source::EventProvenance::observed_at_unix_ms(&self) -> u64
+pub const fn radroots_transport::source::EventProvenance::target(&self) -> &radroots_transport::target::TargetFingerprint
+pub const fn radroots_transport::source::EventProvenance::transport_id(&self) -> radroots_transport::TransportId
+pub fn radroots_transport::source::EventProvenance::with_cursor(self, radroots_transport::source::FetchCursor) -> Self
+impl<'de> serde_core::de::Deserialize<'de> for radroots_transport::source::EventProvenance
+pub fn radroots_transport::source::EventProvenance::deserialize<D>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> where D: serde_core::de::Deserializer<'de>
+pub struct radroots_transport::source::FetchBounds
+impl radroots_transport::source::FetchBounds
+pub const fn radroots_transport::source::FetchBounds::deadline_unix_ms(self) -> u64
+pub const fn radroots_transport::source::FetchBounds::limit(self) -> u16
+pub const fn radroots_transport::source::FetchBounds::new(u16, u64) -> core::result::Result<Self, radroots_transport::error::Error>
+impl<'de> serde_core::de::Deserialize<'de> for radroots_transport::source::FetchBounds
+pub fn radroots_transport::source::FetchBounds::deserialize<D>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> where D: serde_core::de::Deserializer<'de>
+pub struct radroots_transport::source::FetchCursor(_)
+impl radroots_transport::source::FetchCursor
+pub fn radroots_transport::source::FetchCursor::as_str(&self) -> &str
+pub fn radroots_transport::source::FetchCursor::parse(impl core::convert::Into<alloc::string::String>) -> core::result::Result<Self, radroots_transport::error::Error>
+impl core::fmt::Display for radroots_transport::source::FetchCursor
+pub fn radroots_transport::source::FetchCursor::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl serde_core::ser::Serialize for radroots_transport::source::FetchCursor
+pub fn radroots_transport::source::FetchCursor::serialize<S>(&self, S) -> core::result::Result<<S as serde_core::ser::Serializer>::Ok, <S as serde_core::ser::Serializer>::Error> where S: serde_core::ser::Serializer
+impl<'de> serde_core::de::Deserialize<'de> for radroots_transport::source::FetchCursor
+pub fn radroots_transport::source::FetchCursor::deserialize<D>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> where D: serde_core::de::Deserializer<'de>
+pub struct radroots_transport::source::FetchPage
+impl radroots_transport::source::FetchPage
+pub fn radroots_transport::source::FetchPage::events(&self) -> &[radroots_transport::source::ObservedEvent]
+pub fn radroots_transport::source::FetchPage::for_request(&radroots_transport::source::FetchRequest, alloc::vec::Vec<radroots_transport::source::ObservedEvent>, alloc::vec::Vec<radroots_transport::outcome::FetchTargetOutcome>, radroots_transport::source::NextPage) -> core::result::Result<Self, radroots_transport::error::Error>
+pub const fn radroots_transport::source::FetchPage::next_page(&self) -> &radroots_transport::source::NextPage
+pub const fn radroots_transport::source::FetchPage::request_id(&self) -> &radroots_transport::source::FetchRequestId
+pub fn radroots_transport::source::FetchPage::target_outcomes(&self) -> &[radroots_transport::outcome::FetchTargetOutcome]
+pub fn radroots_transport::source::FetchPage::validate(&self) -> core::result::Result<(), radroots_transport::error::Error>
+pub fn radroots_transport::source::FetchPage::validate_for_request(&self, &radroots_transport::source::FetchRequest) -> core::result::Result<(), radroots_transport::error::Error>
+impl<'de> serde_core::de::Deserialize<'de> for radroots_transport::source::FetchPage
+pub fn radroots_transport::source::FetchPage::deserialize<D>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> where D: serde_core::de::Deserializer<'de>
+pub struct radroots_transport::source::FetchRequest
+impl radroots_transport::source::FetchRequest
+pub const fn radroots_transport::source::FetchRequest::bounds(&self) -> radroots_transport::source::FetchBounds
+pub fn radroots_transport::source::FetchRequest::cursor(&self) -> core::option::Option<&radroots_transport::source::FetchCursor>
+pub fn radroots_transport::source::FetchRequest::new(impl core::convert::Into<alloc::string::String>, radroots_transport::target::TargetSet, radroots_transport::source::FetchBounds) -> core::result::Result<Self, radroots_transport::error::Error>
+pub fn radroots_transport::source::FetchRequest::request_id(&self) -> &radroots_transport::source::FetchRequestId
+pub fn radroots_transport::source::FetchRequest::target_set(&self) -> &radroots_transport::target::TargetSet
+pub fn radroots_transport::source::FetchRequest::with_cursor(self, radroots_transport::source::FetchCursor) -> Self
+impl<'de> serde_core::de::Deserialize<'de> for radroots_transport::source::FetchRequest
+pub fn radroots_transport::source::FetchRequest::deserialize<D>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> where D: serde_core::de::Deserializer<'de>
+pub struct radroots_transport::source::FetchRequestId(_)
+impl radroots_transport::source::FetchRequestId
+pub fn radroots_transport::source::FetchRequestId::as_str(&self) -> &str
+pub fn radroots_transport::source::FetchRequestId::parse(impl core::convert::Into<alloc::string::String>) -> core::result::Result<Self, radroots_transport::error::Error>
+impl core::fmt::Display for radroots_transport::source::FetchRequestId
+pub fn radroots_transport::source::FetchRequestId::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl serde_core::ser::Serialize for radroots_transport::source::FetchRequestId
+pub fn radroots_transport::source::FetchRequestId::serialize<S>(&self, S) -> core::result::Result<<S as serde_core::ser::Serializer>::Ok, <S as serde_core::ser::Serializer>::Error> where S: serde_core::ser::Serializer
+impl<'de> serde_core::de::Deserialize<'de> for radroots_transport::source::FetchRequestId
+pub fn radroots_transport::source::FetchRequestId::deserialize<D>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> where D: serde_core::de::Deserializer<'de>
+pub struct radroots_transport::source::ObservedEvent
+impl radroots_transport::source::ObservedEvent
+pub const fn radroots_transport::source::ObservedEvent::event(&self) -> &radroots_event::draft::SignedEvent
+pub const fn radroots_transport::source::ObservedEvent::new(radroots_event::draft::SignedEvent, radroots_transport::source::EventProvenance) -> Self
+pub const fn radroots_transport::source::ObservedEvent::provenance(&self) -> &radroots_transport::source::EventProvenance
+pub struct radroots_transport::source::SourceStatus
+impl radroots_transport::SourceStatus
+pub const fn radroots_transport::SourceStatus::availability(&self) -> radroots_transport::capability::Availability
+pub const fn radroots_transport::SourceStatus::capabilities(&self) -> radroots_transport::capability::SourceCapabilities
+pub fn radroots_transport::SourceStatus::from_descriptor(&radroots_protocol::capability::v1::TransportDescriptor, bool, impl core::convert::Into<alloc::string::String>) -> Self
+pub const fn radroots_transport::SourceStatus::is_configured(&self) -> bool
+pub const fn radroots_transport::SourceStatus::maturity(&self) -> radroots_transport::capability::Maturity
+pub fn radroots_transport::SourceStatus::message(&self) -> &str
+pub fn radroots_transport::SourceStatus::new(radroots_transport::TransportId, bool, radroots_transport::capability::Maturity, radroots_transport::capability::Availability, radroots_transport::capability::SourceCapabilities, impl core::convert::Into<alloc::string::String>) -> Self
+pub const fn radroots_transport::SourceStatus::transport_id(&self) -> radroots_transport::TransportId
+pub const radroots_transport::source::FETCH_CURSOR_MAX_BYTES: usize
+pub const radroots_transport::source::FETCH_PAGE_MAX_EVENTS: u16
+pub const radroots_transport::source::FETCH_REQUEST_ID_MAX_BYTES: usize
+pub trait radroots_transport::source::EventSource: core::marker::Send + core::marker::Sync
+pub fn radroots_transport::source::EventSource::fetch(&self, radroots_transport::source::FetchRequest) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_transport::source::FetchPage, radroots_transport::error::Error>>
+pub fn radroots_transport::source::EventSource::status(&self) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_transport::SourceStatus, radroots_transport::error::Error>>
+pub type radroots_transport::source::BoxFuture<'a, T> = core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = T> + core::marker::Send + 'a)>>
+pub mod radroots_transport::target
+pub struct radroots_transport::target::EndpointUri(_)
+impl radroots_transport::target::EndpointUri
+pub fn radroots_transport::target::EndpointUri::as_str(&self) -> &str
+pub fn radroots_transport::target::EndpointUri::parse(impl core::convert::AsRef<str>) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+impl core::convert::AsRef<str> for radroots_transport::target::EndpointUri
+pub fn radroots_transport::target::EndpointUri::as_ref(&self) -> &str
+impl core::convert::TryFrom<&str> for radroots_transport::target::EndpointUri
+pub type radroots_transport::target::EndpointUri::Error = radroots_transport::error::RadrootsTransportError
+pub fn radroots_transport::target::EndpointUri::try_from(&str) -> core::result::Result<Self, Self::Error>
+impl core::fmt::Display for radroots_transport::target::EndpointUri
+pub fn radroots_transport::target::EndpointUri::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl core::str::traits::FromStr for radroots_transport::target::EndpointUri
+pub type radroots_transport::target::EndpointUri::Err = radroots_transport::error::RadrootsTransportError
+pub fn radroots_transport::target::EndpointUri::from_str(&str) -> core::result::Result<Self, Self::Err>
+impl<'de> serde_core::de::Deserialize<'de> for radroots_transport::target::EndpointUri
+pub fn radroots_transport::target::EndpointUri::deserialize<D>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> where D: serde_core::de::Deserializer<'de>
+pub struct radroots_transport::target::Target
+impl radroots_transport::target::Target
+pub fn radroots_transport::target::Target::fingerprint(&self) -> &radroots_transport::target::TargetFingerprint
+pub fn radroots_transport::target::Target::kind(&self) -> &RadrootsTransportKind
+pub fn radroots_transport::target::Target::label(&self) -> core::option::Option<&radroots_transport::target::TargetLabel>
+pub fn radroots_transport::target::Target::local(impl core::convert::AsRef<str>) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+pub fn radroots_transport::target::Target::local_with_metadata(impl core::convert::AsRef<str>, core::option::Option<radroots_transport::target::TargetScope>, core::option::Option<radroots_transport::target::TargetLabel>) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+pub fn radroots_transport::target::Target::new(RadrootsTransportKind, impl core::convert::AsRef<str>) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+pub fn radroots_transport::target::Target::new_with_metadata(RadrootsTransportKind, impl core::convert::AsRef<str>, core::option::Option<radroots_transport::target::TargetScope>, core::option::Option<radroots_transport::target::TargetLabel>) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+pub fn radroots_transport::target::Target::nostr_relay(impl core::convert::AsRef<str>) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+pub fn radroots_transport::target::Target::nostr_relay_with_metadata(impl core::convert::AsRef<str>, core::option::Option<radroots_transport::target::TargetScope>, core::option::Option<radroots_transport::target::TargetLabel>) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+pub fn radroots_transport::target::Target::reticulum() -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+pub fn radroots_transport::target::Target::reticulum_with_metadata(impl core::convert::AsRef<str>, core::option::Option<radroots_transport::target::TargetScope>, core::option::Option<radroots_transport::target::TargetLabel>) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+pub fn radroots_transport::target::Target::scope(&self) -> core::option::Option<&radroots_transport::target::TargetScope>
+pub fn radroots_transport::target::Target::uri(&self) -> &radroots_transport::target::EndpointUri
+impl<'de> serde_core::de::Deserialize<'de> for radroots_transport::target::Target
+pub fn radroots_transport::target::Target::deserialize<D>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> where D: serde_core::de::Deserializer<'de>
+pub struct radroots_transport::target::TargetFingerprint(_)
+impl radroots_transport::target::TargetFingerprint
+pub fn radroots_transport::target::TargetFingerprint::as_str(&self) -> &str
+pub fn radroots_transport::target::TargetFingerprint::from_target(&RadrootsTransportKind, &radroots_transport::target::EndpointUri, core::option::Option<&radroots_transport::target::TargetScope>) -> Self
+pub fn radroots_transport::target::TargetFingerprint::parse(impl core::convert::AsRef<str>) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+impl core::convert::AsRef<str> for radroots_transport::target::TargetFingerprint
+pub fn radroots_transport::target::TargetFingerprint::as_ref(&self) -> &str
+impl core::convert::TryFrom<&str> for radroots_transport::target::TargetFingerprint
+pub type radroots_transport::target::TargetFingerprint::Error = radroots_transport::error::RadrootsTransportError
+pub fn radroots_transport::target::TargetFingerprint::try_from(&str) -> core::result::Result<Self, Self::Error>
+impl core::fmt::Display for radroots_transport::target::TargetFingerprint
+pub fn radroots_transport::target::TargetFingerprint::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl core::str::traits::FromStr for radroots_transport::target::TargetFingerprint
+pub type radroots_transport::target::TargetFingerprint::Err = radroots_transport::error::RadrootsTransportError
+pub fn radroots_transport::target::TargetFingerprint::from_str(&str) -> core::result::Result<Self, Self::Err>
+impl<'de> serde_core::de::Deserialize<'de> for radroots_transport::target::TargetFingerprint
+pub fn radroots_transport::target::TargetFingerprint::deserialize<D>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> where D: serde_core::de::Deserializer<'de>
+pub struct radroots_transport::target::TargetLabel(_)
+impl radroots_transport::target::TargetLabel
+pub fn radroots_transport::target::TargetLabel::as_str(&self) -> &str
+pub fn radroots_transport::target::TargetLabel::parse(impl core::convert::AsRef<str>) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+impl core::convert::AsRef<str> for radroots_transport::target::TargetLabel
+pub fn radroots_transport::target::TargetLabel::as_ref(&self) -> &str
+impl core::convert::TryFrom<&str> for radroots_transport::target::TargetLabel
+pub type radroots_transport::target::TargetLabel::Error = radroots_transport::error::RadrootsTransportError
+pub fn radroots_transport::target::TargetLabel::try_from(&str) -> core::result::Result<Self, Self::Error>
+impl core::fmt::Display for radroots_transport::target::TargetLabel
+pub fn radroots_transport::target::TargetLabel::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl core::str::traits::FromStr for radroots_transport::target::TargetLabel
+pub type radroots_transport::target::TargetLabel::Err = radroots_transport::error::RadrootsTransportError
+pub fn radroots_transport::target::TargetLabel::from_str(&str) -> core::result::Result<Self, Self::Err>
+impl<'de> serde_core::de::Deserialize<'de> for radroots_transport::target::TargetLabel
+pub fn radroots_transport::target::TargetLabel::deserialize<D>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> where D: serde_core::de::Deserializer<'de>
+pub struct radroots_transport::target::TargetScope(_)
+impl radroots_transport::target::TargetScope
+pub fn radroots_transport::target::TargetScope::as_str(&self) -> &str
+pub fn radroots_transport::target::TargetScope::local_reticulum() -> Self
+pub fn radroots_transport::target::TargetScope::parse(impl core::convert::AsRef<str>) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+impl core::convert::AsRef<str> for radroots_transport::target::TargetScope
+pub fn radroots_transport::target::TargetScope::as_ref(&self) -> &str
+impl core::convert::TryFrom<&str> for radroots_transport::target::TargetScope
+pub type radroots_transport::target::TargetScope::Error = radroots_transport::error::RadrootsTransportError
+pub fn radroots_transport::target::TargetScope::try_from(&str) -> core::result::Result<Self, Self::Error>
+impl core::fmt::Display for radroots_transport::target::TargetScope
+pub fn radroots_transport::target::TargetScope::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl core::str::traits::FromStr for radroots_transport::target::TargetScope
+pub type radroots_transport::target::TargetScope::Err = radroots_transport::error::RadrootsTransportError
+pub fn radroots_transport::target::TargetScope::from_str(&str) -> core::result::Result<Self, Self::Err>
+impl<'de> serde_core::de::Deserialize<'de> for radroots_transport::target::TargetScope
+pub fn radroots_transport::target::TargetScope::deserialize<D>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> where D: serde_core::de::Deserializer<'de>
+pub struct radroots_transport::target::TargetSet
+impl radroots_transport::target::TargetSet
+pub fn radroots_transport::target::TargetSet::is_empty(&self) -> bool
+pub fn radroots_transport::target::TargetSet::len(&self) -> usize
+pub fn radroots_transport::target::TargetSet::new(alloc::vec::Vec<radroots_transport::target::Target>) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+pub fn radroots_transport::target::TargetSet::targets(&self) -> &[radroots_transport::target::Target]
+impl<'de> serde_core::de::Deserialize<'de> for radroots_transport::target::TargetSet
+pub fn radroots_transport::target::TargetSet::deserialize<D>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> where D: serde_core::de::Deserializer<'de>
+pub const radroots_transport::target::TARGET_SET_MAX_ITEMS: usize
+pub enum radroots_transport::RadrootsTransportDeliveryTargetStatus
+pub radroots_transport::RadrootsTransportDeliveryTargetStatus::Accepted
+pub radroots_transport::RadrootsTransportDeliveryTargetStatus::DeferredUntilImplemented
+pub radroots_transport::RadrootsTransportDeliveryTargetStatus::Delivered
+pub radroots_transport::RadrootsTransportDeliveryTargetStatus::FailedRetryable
+pub radroots_transport::RadrootsTransportDeliveryTargetStatus::FailedTerminal
+pub radroots_transport::RadrootsTransportDeliveryTargetStatus::Forwarded
+pub radroots_transport::RadrootsTransportDeliveryTargetStatus::Pending
+pub radroots_transport::RadrootsTransportDeliveryTargetStatus::Seen
+pub radroots_transport::RadrootsTransportDeliveryTargetStatus::SkippedPolicyDenied
+pub radroots_transport::RadrootsTransportDeliveryTargetStatus::StoredByGateway
+impl radroots_transport::RadrootsTransportDeliveryTargetStatus
+pub fn radroots_transport::RadrootsTransportDeliveryTargetStatus::counts_as_accepted_satisfaction(self) -> bool
+pub fn radroots_transport::RadrootsTransportDeliveryTargetStatus::counts_as_delivered_satisfaction(self) -> bool
+pub fn radroots_transport::RadrootsTransportDeliveryTargetStatus::counts_as_satisfied(self, radroots_transport::RadrootsTransportSatisfactionClass) -> bool
+pub fn radroots_transport::RadrootsTransportDeliveryTargetStatus::is_deferred_until_implemented(self) -> bool
+pub fn radroots_transport::RadrootsTransportDeliveryTargetStatus::is_ready_for_attempt(self) -> bool
+pub fn radroots_transport::RadrootsTransportDeliveryTargetStatus::is_retryable_failure(self) -> bool
+pub fn radroots_transport::RadrootsTransportDeliveryTargetStatus::is_terminal_failure(self) -> bool
+pub enum radroots_transport::RadrootsTransportError
+pub radroots_transport::RadrootsTransportError::DeliveryReceiptRequestIdMismatch
+pub radroots_transport::RadrootsTransportError::DeliveryReceiptTargetSetMismatch
+pub radroots_transport::RadrootsTransportError::DeliveryTargetReceiptAttemptMismatch
+pub radroots_transport::RadrootsTransportError::DeliveryTargetReceiptStatusMismatch
+pub radroots_transport::RadrootsTransportError::DuplicateDeliveryTargetReceipt
+pub radroots_transport::RadrootsTransportError::DuplicateFetchTargetOutcome
+pub radroots_transport::RadrootsTransportError::DuplicateRequiredTargetFingerprint
+pub radroots_transport::RadrootsTransportError::DuplicateTargetFingerprint
+pub radroots_transport::RadrootsTransportError::EmptyDeliveryRequestId
+pub radroots_transport::RadrootsTransportError::EmptyFetchCursor
+pub radroots_transport::RadrootsTransportError::EmptyFetchRequestId
+pub radroots_transport::RadrootsTransportError::EmptyPayloadBytes
+pub radroots_transport::RadrootsTransportError::EmptyPayloadId
+pub radroots_transport::RadrootsTransportError::EmptyPayloadLabel
+pub radroots_transport::RadrootsTransportError::EmptyRequiredTargetSet
+pub radroots_transport::RadrootsTransportError::EmptyTargetLabel
+pub radroots_transport::RadrootsTransportError::EmptyTargetScope
+pub radroots_transport::RadrootsTransportError::EmptyTargetSet
+pub radroots_transport::RadrootsTransportError::EmptyTargetUri
+pub radroots_transport::RadrootsTransportError::EmptyTransportKind
+pub radroots_transport::RadrootsTransportError::FetchPageLimitExceeded
+pub radroots_transport::RadrootsTransportError::FetchPageRequestMismatch
+pub radroots_transport::RadrootsTransportError::InvalidDeliveryDeadline
+pub radroots_transport::RadrootsTransportError::InvalidDeliveryOutcome
+pub radroots_transport::RadrootsTransportError::InvalidDeliveryRequestId
+pub radroots_transport::RadrootsTransportError::InvalidDeliveryTimestamp
+pub radroots_transport::RadrootsTransportError::InvalidFetchCursor
+pub radroots_transport::RadrootsTransportError::InvalidFetchDeadline
+pub radroots_transport::RadrootsTransportError::InvalidFetchLimit
+pub radroots_transport::RadrootsTransportError::InvalidFetchRequestId
+pub radroots_transport::RadrootsTransportError::InvalidObservedAt
+pub radroots_transport::RadrootsTransportError::InvalidPayloadBytes
+pub radroots_transport::RadrootsTransportError::InvalidPayloadDigest
+pub radroots_transport::RadrootsTransportError::InvalidPayloadId
+pub radroots_transport::RadrootsTransportError::InvalidPayloadLabel
+pub radroots_transport::RadrootsTransportError::InvalidSatisfactionPolicy
+pub radroots_transport::RadrootsTransportError::InvalidTargetFingerprint
+pub radroots_transport::RadrootsTransportError::InvalidTargetLabel
+pub radroots_transport::RadrootsTransportError::InvalidTargetScope
+pub radroots_transport::RadrootsTransportError::InvalidTargetUri
+pub radroots_transport::RadrootsTransportError::InvalidTransportKind
+pub radroots_transport::RadrootsTransportError::MissingDeliveryTargetReceipt
+pub radroots_transport::RadrootsTransportError::PayloadDigestMismatch
+pub radroots_transport::RadrootsTransportError::RequiredTargetNotRequested
+pub radroots_transport::RadrootsTransportError::TargetSetTooLarge
+pub radroots_transport::RadrootsTransportError::TransportOutcomeStatusMismatch
+pub radroots_transport::RadrootsTransportError::UnexpectedDeliveryTargetReceipt
+pub radroots_transport::RadrootsTransportError::UnexpectedFetchProvenance
+pub radroots_transport::RadrootsTransportError::UnexpectedFetchTargetOutcome
+pub radroots_transport::RadrootsTransportError::UnsupportedOperation
+impl core::fmt::Display for radroots_transport::error::RadrootsTransportError
+pub fn radroots_transport::error::RadrootsTransportError::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub enum radroots_transport::RadrootsTransportImplementationState
+pub radroots_transport::RadrootsTransportImplementationState::Mock
+pub radroots_transport::RadrootsTransportImplementationState::Real
+pub enum radroots_transport::RadrootsTransportOutcomeKind
+pub radroots_transport::RadrootsTransportOutcomeKind::Accepted
+pub radroots_transport::RadrootsTransportOutcomeKind::ConnectionFailed
+pub radroots_transport::RadrootsTransportOutcomeKind::DeferredUntilImplemented
+pub radroots_transport::RadrootsTransportOutcomeKind::Delivered
+pub radroots_transport::RadrootsTransportOutcomeKind::DuplicateAccepted
+pub radroots_transport::RadrootsTransportOutcomeKind::Forwarded
+pub radroots_transport::RadrootsTransportOutcomeKind::PayloadTooLarge
+pub radroots_transport::RadrootsTransportOutcomeKind::PolicyDenied
+pub radroots_transport::RadrootsTransportOutcomeKind::Rejected
+pub radroots_transport::RadrootsTransportOutcomeKind::RouteUnavailable
+pub radroots_transport::RadrootsTransportOutcomeKind::Seen
+pub radroots_transport::RadrootsTransportOutcomeKind::StoredByGateway
+pub radroots_transport::RadrootsTransportOutcomeKind::Timeout
+pub radroots_transport::RadrootsTransportOutcomeKind::TransportUnavailable
+impl radroots_transport::RadrootsTransportOutcomeKind
+pub fn radroots_transport::RadrootsTransportOutcomeKind::as_str(self) -> &'static str
+pub fn radroots_transport::RadrootsTransportOutcomeKind::counts_as_satisfied(self, radroots_transport::RadrootsTransportSatisfactionClass) -> bool
+pub fn radroots_transport::RadrootsTransportOutcomeKind::target_status(self) -> radroots_transport::RadrootsTransportDeliveryTargetStatus
+pub enum radroots_transport::RadrootsTransportPayload
+pub radroots_transport::RadrootsTransportPayload::MeshFrameCbor
+pub radroots_transport::RadrootsTransportPayload::MeshFrameCbor::bytes: alloc::vec::Vec<u8>
+pub radroots_transport::RadrootsTransportPayload::MeshFrameCbor::digest: alloc::string::String
+pub radroots_transport::RadrootsTransportPayload::MeshFrameCbor::message_id: alloc::string::String
+pub radroots_transport::RadrootsTransportPayload::OpaqueBytes
+pub radroots_transport::RadrootsTransportPayload::OpaqueBytes::bytes: alloc::vec::Vec<u8>
+pub radroots_transport::RadrootsTransportPayload::OpaqueBytes::digest: alloc::string::String
+pub radroots_transport::RadrootsTransportPayload::OpaqueBytes::label: alloc::string::String
+pub radroots_transport::RadrootsTransportPayload::SignedEventJson
+pub radroots_transport::RadrootsTransportPayload::SignedEventJson::digest: alloc::string::String
+pub radroots_transport::RadrootsTransportPayload::SignedEventJson::event_id: alloc::string::String
+pub radroots_transport::RadrootsTransportPayload::SignedEventJson::raw_json: alloc::string::String
+impl radroots_transport::RadrootsTransportPayload
+pub fn radroots_transport::RadrootsTransportPayload::digest(&self) -> &str
+pub fn radroots_transport::RadrootsTransportPayload::mesh_frame_cbor(impl core::convert::AsRef<str>, impl core::convert::AsRef<[u8]>) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+pub fn radroots_transport::RadrootsTransportPayload::mesh_frame_cbor_with_digest(impl core::convert::AsRef<str>, impl core::convert::AsRef<[u8]>, impl core::convert::AsRef<str>) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+pub fn radroots_transport::RadrootsTransportPayload::opaque_bytes(impl core::convert::AsRef<str>, impl core::convert::AsRef<[u8]>) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+pub fn radroots_transport::RadrootsTransportPayload::opaque_bytes_with_digest(impl core::convert::AsRef<str>, impl core::convert::AsRef<[u8]>, impl core::convert::AsRef<str>) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+pub fn radroots_transport::RadrootsTransportPayload::payload_kind(&self) -> &'static str
+pub fn radroots_transport::RadrootsTransportPayload::unchecked_signed_event_json(impl core::convert::AsRef<str>, impl core::convert::AsRef<str>) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+pub fn radroots_transport::RadrootsTransportPayload::unchecked_signed_event_json_with_digest(impl core::convert::AsRef<str>, impl core::convert::AsRef<str>, impl core::convert::AsRef<str>) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+pub fn radroots_transport::RadrootsTransportPayload::validate(&self) -> core::result::Result<(), radroots_transport::error::RadrootsTransportError>
+impl<'de> serde_core::de::Deserialize<'de> for radroots_transport::RadrootsTransportPayload
+pub fn radroots_transport::RadrootsTransportPayload::deserialize<D>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> where D: serde_core::de::Deserializer<'de>
+pub enum radroots_transport::RadrootsTransportSatisfactionClass
+pub radroots_transport::RadrootsTransportSatisfactionClass::Accepted
+pub radroots_transport::RadrootsTransportSatisfactionClass::Delivered
+pub radroots_transport::RadrootsTransportSatisfactionClass::DurableOrObserved
+pub radroots_transport::RadrootsTransportSatisfactionClass::Forwarded
+pub radroots_transport::RadrootsTransportSatisfactionClass::Seen
+pub radroots_transport::RadrootsTransportSatisfactionClass::Stored
+pub enum radroots_transport::RadrootsTransportSatisfactionPolicy
+pub radroots_transport::RadrootsTransportSatisfactionPolicy::All
+pub radroots_transport::RadrootsTransportSatisfactionPolicy::All::class: radroots_transport::RadrootsTransportSatisfactionClass
+pub radroots_transport::RadrootsTransportSatisfactionPolicy::Any
+pub radroots_transport::RadrootsTransportSatisfactionPolicy::Any::class: radroots_transport::RadrootsTransportSatisfactionClass
+pub radroots_transport::RadrootsTransportSatisfactionPolicy::NoWait
+pub radroots_transport::RadrootsTransportSatisfactionPolicy::Quorum
+pub radroots_transport::RadrootsTransportSatisfactionPolicy::Quorum::class: radroots_transport::RadrootsTransportSatisfactionClass
+pub radroots_transport::RadrootsTransportSatisfactionPolicy::Quorum::threshold: u16
+pub radroots_transport::RadrootsTransportSatisfactionPolicy::RequiredTargets
+pub radroots_transport::RadrootsTransportSatisfactionPolicy::RequiredTargets::class: radroots_transport::RadrootsTransportSatisfactionClass
+pub radroots_transport::RadrootsTransportSatisfactionPolicy::RequiredTargets::targets: alloc::vec::Vec<crate::RadrootsTransportTargetFingerprint>
+impl radroots_transport::RadrootsTransportSatisfactionPolicy
+pub fn radroots_transport::RadrootsTransportSatisfactionPolicy::all_accepted() -> Self
+pub fn radroots_transport::RadrootsTransportSatisfactionPolicy::all_delivered() -> Self
+pub fn radroots_transport::RadrootsTransportSatisfactionPolicy::all_durable_or_observed() -> Self
+pub fn radroots_transport::RadrootsTransportSatisfactionPolicy::all_forwarded() -> Self
+pub fn radroots_transport::RadrootsTransportSatisfactionPolicy::all_seen() -> Self
+pub fn radroots_transport::RadrootsTransportSatisfactionPolicy::all_stored() -> Self
+pub fn radroots_transport::RadrootsTransportSatisfactionPolicy::any_accepted() -> Self
+pub fn radroots_transport::RadrootsTransportSatisfactionPolicy::any_delivered() -> Self
+pub fn radroots_transport::RadrootsTransportSatisfactionPolicy::any_durable_or_observed() -> Self
+pub fn radroots_transport::RadrootsTransportSatisfactionPolicy::any_forwarded() -> Self
+pub fn radroots_transport::RadrootsTransportSatisfactionPolicy::any_seen() -> Self
+pub fn radroots_transport::RadrootsTransportSatisfactionPolicy::any_stored() -> Self
+pub fn radroots_transport::RadrootsTransportSatisfactionPolicy::is_satisfied_by(&self, usize, usize) -> core::result::Result<bool, radroots_transport::error::RadrootsTransportError>
+pub fn radroots_transport::RadrootsTransportSatisfactionPolicy::no_wait() -> Self
+pub fn radroots_transport::RadrootsTransportSatisfactionPolicy::quorum_accepted(u16) -> Self
+pub fn radroots_transport::RadrootsTransportSatisfactionPolicy::quorum_delivered(u16) -> Self
+pub fn radroots_transport::RadrootsTransportSatisfactionPolicy::quorum_durable_or_observed(u16) -> Self
+pub fn radroots_transport::RadrootsTransportSatisfactionPolicy::quorum_forwarded(u16) -> Self
+pub fn radroots_transport::RadrootsTransportSatisfactionPolicy::quorum_seen(u16) -> Self
+pub fn radroots_transport::RadrootsTransportSatisfactionPolicy::quorum_stored(u16) -> Self
+pub fn radroots_transport::RadrootsTransportSatisfactionPolicy::required_target_count(&self, usize) -> core::result::Result<usize, radroots_transport::error::RadrootsTransportError>
+pub fn radroots_transport::RadrootsTransportSatisfactionPolicy::required_target_fingerprints(&self) -> core::option::Option<&[RadrootsTransportTargetFingerprint]>
+pub fn radroots_transport::RadrootsTransportSatisfactionPolicy::required_targets(radroots_transport::RadrootsTransportSatisfactionClass, alloc::vec::Vec<RadrootsTransportTargetFingerprint>) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+pub fn radroots_transport::RadrootsTransportSatisfactionPolicy::target_satisfaction_class(&self) -> core::option::Option<radroots_transport::RadrootsTransportSatisfactionClass>
+pub fn radroots_transport::RadrootsTransportSatisfactionPolicy::validate_for_target_set(&self, &RadrootsTransportTargetSet) -> core::result::Result<(), radroots_transport::error::RadrootsTransportError>
+impl<'de> serde_core::de::Deserialize<'de> for radroots_transport::RadrootsTransportSatisfactionPolicy
+pub fn radroots_transport::RadrootsTransportSatisfactionPolicy::deserialize<D>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> where D: serde_core::de::Deserializer<'de>
+pub struct radroots_transport::DeliveryReceipt
+impl radroots_transport::sink::DeliveryReceipt
+pub fn radroots_transport::sink::DeliveryReceipt::for_request(&radroots_transport::sink::DeliveryRequest, alloc::vec::Vec<radroots_transport::sink::DeliveryTargetReceipt>) -> core::result::Result<Self, radroots_transport::error::Error>
+pub fn radroots_transport::sink::DeliveryReceipt::is_satisfied(&self, &radroots_transport::sink::DeliveryRequest) -> core::result::Result<bool, radroots_transport::error::Error>
+pub const fn radroots_transport::sink::DeliveryReceipt::request_id(&self) -> &radroots_transport::sink::DeliveryRequestId
+pub fn radroots_transport::sink::DeliveryReceipt::target_receipts(&self) -> &[radroots_transport::sink::DeliveryTargetReceipt]
+pub fn radroots_transport::sink::DeliveryReceipt::validate_for_request(&self, &radroots_transport::sink::DeliveryRequest) -> core::result::Result<(), radroots_transport::error::Error>
+impl<'de> serde_core::de::Deserialize<'de> for radroots_transport::sink::DeliveryReceipt
+pub fn radroots_transport::sink::DeliveryReceipt::deserialize<D>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> where D: serde_core::de::Deserializer<'de>
+pub struct radroots_transport::DeliveryRequest
+impl radroots_transport::sink::DeliveryRequest
+pub const fn radroots_transport::sink::DeliveryRequest::deadline_unix_ms(&self) -> u64
+pub fn radroots_transport::sink::DeliveryRequest::new(impl core::convert::Into<alloc::string::String>, radroots_transport::sink::DeliveryPayload, radroots_transport::target::TargetSet, radroots_transport::policy::SatisfactionPolicy, u64) -> core::result::Result<Self, radroots_transport::error::Error>
+pub const fn radroots_transport::sink::DeliveryRequest::payload(&self) -> &radroots_transport::sink::DeliveryPayload
+pub const fn radroots_transport::sink::DeliveryRequest::request_id(&self) -> &radroots_transport::sink::DeliveryRequestId
+pub const fn radroots_transport::sink::DeliveryRequest::satisfaction(&self) -> &radroots_transport::policy::SatisfactionPolicy
+pub const fn radroots_transport::sink::DeliveryRequest::target_set(&self) -> &radroots_transport::target::TargetSet
+impl<'de> serde_core::de::Deserialize<'de> for radroots_transport::sink::DeliveryRequest
+pub fn radroots_transport::sink::DeliveryRequest::deserialize<D>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> where D: serde_core::de::Deserializer<'de>
+pub struct radroots_transport::FetchPage
+impl radroots_transport::source::FetchPage
+pub fn radroots_transport::source::FetchPage::events(&self) -> &[radroots_transport::source::ObservedEvent]
+pub fn radroots_transport::source::FetchPage::for_request(&radroots_transport::source::FetchRequest, alloc::vec::Vec<radroots_transport::source::ObservedEvent>, alloc::vec::Vec<radroots_transport::outcome::FetchTargetOutcome>, radroots_transport::source::NextPage) -> core::result::Result<Self, radroots_transport::error::Error>
+pub const fn radroots_transport::source::FetchPage::next_page(&self) -> &radroots_transport::source::NextPage
+pub const fn radroots_transport::source::FetchPage::request_id(&self) -> &radroots_transport::source::FetchRequestId
+pub fn radroots_transport::source::FetchPage::target_outcomes(&self) -> &[radroots_transport::outcome::FetchTargetOutcome]
+pub fn radroots_transport::source::FetchPage::validate(&self) -> core::result::Result<(), radroots_transport::error::Error>
+pub fn radroots_transport::source::FetchPage::validate_for_request(&self, &radroots_transport::source::FetchRequest) -> core::result::Result<(), radroots_transport::error::Error>
+impl<'de> serde_core::de::Deserialize<'de> for radroots_transport::source::FetchPage
+pub fn radroots_transport::source::FetchPage::deserialize<D>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> where D: serde_core::de::Deserializer<'de>
+pub struct radroots_transport::FetchRequest
+impl radroots_transport::source::FetchRequest
+pub const fn radroots_transport::source::FetchRequest::bounds(&self) -> radroots_transport::source::FetchBounds
+pub fn radroots_transport::source::FetchRequest::cursor(&self) -> core::option::Option<&radroots_transport::source::FetchCursor>
+pub fn radroots_transport::source::FetchRequest::new(impl core::convert::Into<alloc::string::String>, radroots_transport::target::TargetSet, radroots_transport::source::FetchBounds) -> core::result::Result<Self, radroots_transport::error::Error>
+pub fn radroots_transport::source::FetchRequest::request_id(&self) -> &radroots_transport::source::FetchRequestId
+pub fn radroots_transport::source::FetchRequest::target_set(&self) -> &radroots_transport::target::TargetSet
+pub fn radroots_transport::source::FetchRequest::with_cursor(self, radroots_transport::source::FetchCursor) -> Self
+impl<'de> serde_core::de::Deserialize<'de> for radroots_transport::source::FetchRequest
+pub fn radroots_transport::source::FetchRequest::deserialize<D>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> where D: serde_core::de::Deserializer<'de>
+pub struct radroots_transport::RadrootsTransportCapabilities
+pub radroots_transport::RadrootsTransportCapabilities::deliver: bool
+pub radroots_transport::RadrootsTransportCapabilities::discovery: bool
+pub radroots_transport::RadrootsTransportCapabilities::fetch: bool
+pub radroots_transport::RadrootsTransportCapabilities::gateway_forwarding: bool
+pub radroots_transport::RadrootsTransportCapabilities::receipt_observation: bool
+impl radroots_transport::RadrootsTransportCapabilities
+pub const fn radroots_transport::RadrootsTransportCapabilities::deliver_and_fetch() -> Self
+pub const fn radroots_transport::RadrootsTransportCapabilities::deliver_only() -> Self
+pub const fn radroots_transport::RadrootsTransportCapabilities::fetch_only() -> Self
+pub const fn radroots_transport::RadrootsTransportCapabilities::none() -> Self
+pub const fn radroots_transport::RadrootsTransportCapabilities::reticulum_unavailable() -> Self
+pub const fn radroots_transport::RadrootsTransportCapabilities::with_discovery(self, bool) -> Self
+pub const fn radroots_transport::RadrootsTransportCapabilities::with_gateway_forwarding(self, bool) -> Self
+pub const fn radroots_transport::RadrootsTransportCapabilities::with_receipt_observation(self, bool) -> Self
+pub struct radroots_transport::RadrootsTransportDeliveryReceipt
+impl radroots_transport::RadrootsTransportDeliveryReceipt
+pub fn radroots_transport::RadrootsTransportDeliveryReceipt::for_request(&radroots_transport::RadrootsTransportDeliveryRequest, alloc::vec::Vec<radroots_transport::RadrootsTransportTargetReceipt>) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+pub fn radroots_transport::RadrootsTransportDeliveryReceipt::is_satisfied_by(&self, &radroots_transport::RadrootsTransportSatisfactionPolicy) -> core::result::Result<bool, radroots_transport::error::RadrootsTransportError>
+pub fn radroots_transport::RadrootsTransportDeliveryReceipt::new(impl core::convert::Into<alloc::string::String>, RadrootsTransportTargetSet, alloc::vec::Vec<radroots_transport::RadrootsTransportTargetReceipt>) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+pub fn radroots_transport::RadrootsTransportDeliveryReceipt::request_id(&self) -> &str
+pub fn radroots_transport::RadrootsTransportDeliveryReceipt::satisfied_target_count(&self, radroots_transport::RadrootsTransportSatisfactionClass) -> usize
+pub fn radroots_transport::RadrootsTransportDeliveryReceipt::target_receipts(&self) -> &[radroots_transport::RadrootsTransportTargetReceipt]
+pub fn radroots_transport::RadrootsTransportDeliveryReceipt::target_set(&self) -> &RadrootsTransportTargetSet
+pub fn radroots_transport::RadrootsTransportDeliveryReceipt::validate_for_request(&self, &radroots_transport::RadrootsTransportDeliveryRequest) -> core::result::Result<(), radroots_transport::error::RadrootsTransportError>
+impl<'de> serde_core::de::Deserialize<'de> for radroots_transport::RadrootsTransportDeliveryReceipt
+pub fn radroots_transport::RadrootsTransportDeliveryReceipt::deserialize<D>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> where D: serde_core::de::Deserializer<'de>
+pub struct radroots_transport::RadrootsTransportDeliveryRequest
+impl radroots_transport::RadrootsTransportDeliveryRequest
+pub fn radroots_transport::RadrootsTransportDeliveryRequest::new(impl core::convert::Into<alloc::string::String>, radroots_transport::RadrootsTransportPayload, RadrootsTransportTargetSet, radroots_transport::RadrootsTransportSatisfactionPolicy) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+pub fn radroots_transport::RadrootsTransportDeliveryRequest::now_ms(&self) -> i64
+pub fn radroots_transport::RadrootsTransportDeliveryRequest::payload(&self) -> &radroots_transport::RadrootsTransportPayload
+pub fn radroots_transport::RadrootsTransportDeliveryRequest::request_id(&self) -> &str
+pub fn radroots_transport::RadrootsTransportDeliveryRequest::satisfaction_policy(&self) -> &radroots_transport::RadrootsTransportSatisfactionPolicy
+pub fn radroots_transport::RadrootsTransportDeliveryRequest::target_set(&self) -> &RadrootsTransportTargetSet
+pub fn radroots_transport::RadrootsTransportDeliveryRequest::try_with_now_ms(self, i64) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+impl<'de> serde_core::de::Deserialize<'de> for radroots_transport::RadrootsTransportDeliveryRequest
+pub fn radroots_transport::RadrootsTransportDeliveryRequest::deserialize<D>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> where D: serde_core::de::Deserializer<'de>
+pub struct radroots_transport::RadrootsTransportFetchReceipt
+pub radroots_transport::RadrootsTransportFetchReceipt::fetched_count: usize
+pub radroots_transport::RadrootsTransportFetchReceipt::request_id: alloc::string::String
+pub radroots_transport::RadrootsTransportFetchReceipt::target_receipts: alloc::vec::Vec<radroots_transport::RadrootsTransportTargetReceipt>
+impl radroots_transport::RadrootsTransportFetchReceipt
+pub fn radroots_transport::RadrootsTransportFetchReceipt::new(impl core::convert::Into<alloc::string::String>, alloc::vec::Vec<radroots_transport::RadrootsTransportTargetReceipt>, usize) -> Self
+pub struct radroots_transport::RadrootsTransportFetchRequest
+pub radroots_transport::RadrootsTransportFetchRequest::request_id: alloc::string::String
+pub radroots_transport::RadrootsTransportFetchRequest::target_set: crate::RadrootsTransportTargetSet
+impl radroots_transport::RadrootsTransportFetchRequest
+pub fn radroots_transport::RadrootsTransportFetchRequest::new(impl core::convert::Into<alloc::string::String>, RadrootsTransportTargetSet) -> Self
+pub struct radroots_transport::RadrootsTransportOutcome
+pub radroots_transport::RadrootsTransportOutcome::code: core::option::Option<alloc::string::String>
+pub radroots_transport::RadrootsTransportOutcome::kind: radroots_transport::RadrootsTransportOutcomeKind
+pub radroots_transport::RadrootsTransportOutcome::message: core::option::Option<alloc::string::String>
+pub radroots_transport::RadrootsTransportOutcome::status: radroots_transport::RadrootsTransportDeliveryTargetStatus
+impl radroots_transport::RadrootsTransportOutcome
+pub fn radroots_transport::RadrootsTransportOutcome::new(radroots_transport::RadrootsTransportOutcomeKind) -> Self
+pub fn radroots_transport::RadrootsTransportOutcome::validate(&self) -> core::result::Result<(), radroots_transport::error::RadrootsTransportError>
+pub fn radroots_transport::RadrootsTransportOutcome::with_code(self, impl core::convert::Into<alloc::string::String>) -> Self
+pub fn radroots_transport::RadrootsTransportOutcome::with_message(self, impl core::convert::Into<alloc::string::String>) -> Self
+impl<'de> serde_core::de::Deserialize<'de> for radroots_transport::RadrootsTransportOutcome
+pub fn radroots_transport::RadrootsTransportOutcome::deserialize<D>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> where D: serde_core::de::Deserializer<'de>
+pub struct radroots_transport::RadrootsTransportStatus
+pub radroots_transport::RadrootsTransportStatus::availability: crate::RadrootsTransportCapabilityAvailability
+pub radroots_transport::RadrootsTransportStatus::capabilities: radroots_transport::RadrootsTransportCapabilities
+pub radroots_transport::RadrootsTransportStatus::configured: bool
+pub radroots_transport::RadrootsTransportStatus::endpoint_uri: core::option::Option<alloc::string::String>
+pub radroots_transport::RadrootsTransportStatus::implementation: radroots_transport::RadrootsTransportImplementationState
+pub radroots_transport::RadrootsTransportStatus::kind: crate::RadrootsTransportKind
+pub radroots_transport::RadrootsTransportStatus::maturity: crate::RadrootsTransportCapabilityMaturity
+pub radroots_transport::RadrootsTransportStatus::message: alloc::string::String
+pub radroots_transport::RadrootsTransportStatus::profile_id: core::option::Option<alloc::string::String>
+pub radroots_transport::RadrootsTransportStatus::usable_for_delivery: bool
+impl radroots_transport::RadrootsTransportStatus
+pub fn radroots_transport::RadrootsTransportStatus::new(RadrootsTransportKind, bool, radroots_transport::RadrootsTransportImplementationState, bool, impl core::convert::Into<alloc::string::String>) -> Self
+pub fn radroots_transport::RadrootsTransportStatus::with_availability(self, RadrootsTransportCapabilityAvailability) -> Self
+pub fn radroots_transport::RadrootsTransportStatus::with_capabilities(self, radroots_transport::RadrootsTransportCapabilities) -> Self
+pub fn radroots_transport::RadrootsTransportStatus::with_endpoint_uri(self, impl core::convert::Into<alloc::string::String>) -> Self
+pub fn radroots_transport::RadrootsTransportStatus::with_maturity(self, RadrootsTransportCapabilityMaturity) -> Self
+pub fn radroots_transport::RadrootsTransportStatus::with_profile_id(self, impl core::convert::Into<alloc::string::String>) -> Self
+pub struct radroots_transport::RadrootsTransportTargetReceipt
+pub radroots_transport::RadrootsTransportTargetReceipt::attempted: bool
+pub radroots_transport::RadrootsTransportTargetReceipt::outcome: radroots_transport::RadrootsTransportOutcome
+pub radroots_transport::RadrootsTransportTargetReceipt::status: radroots_transport::RadrootsTransportDeliveryTargetStatus
+pub radroots_transport::RadrootsTransportTargetReceipt::target: crate::RadrootsTransportTarget
+impl radroots_transport::RadrootsTransportTargetReceipt
+pub fn radroots_transport::RadrootsTransportTargetReceipt::attempted(RadrootsTransportTarget, radroots_transport::RadrootsTransportOutcome) -> Self
+pub fn radroots_transport::RadrootsTransportTargetReceipt::new(RadrootsTransportTarget, radroots_transport::RadrootsTransportOutcome) -> Self
+pub fn radroots_transport::RadrootsTransportTargetReceipt::skipped(RadrootsTransportTarget, radroots_transport::RadrootsTransportOutcome) -> Self
+impl<'de> serde_core::de::Deserialize<'de> for radroots_transport::RadrootsTransportTargetReceipt
+pub fn radroots_transport::RadrootsTransportTargetReceipt::deserialize<D>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> where D: serde_core::de::Deserializer<'de>
+pub struct radroots_transport::SinkStatus
+impl radroots_transport::SinkStatus
+pub const fn radroots_transport::SinkStatus::availability(&self) -> radroots_transport::capability::Availability
+pub const fn radroots_transport::SinkStatus::capabilities(&self) -> radroots_transport::capability::SinkCapabilities
+pub fn radroots_transport::SinkStatus::from_descriptor(&radroots_protocol::capability::v1::TransportDescriptor, bool, impl core::convert::Into<alloc::string::String>) -> Self
+pub const fn radroots_transport::SinkStatus::is_configured(&self) -> bool
+pub const fn radroots_transport::SinkStatus::maturity(&self) -> radroots_transport::capability::Maturity
+pub fn radroots_transport::SinkStatus::message(&self) -> &str
+pub fn radroots_transport::SinkStatus::new(radroots_transport::TransportId, bool, radroots_transport::capability::Maturity, radroots_transport::capability::Availability, radroots_transport::capability::SinkCapabilities, impl core::convert::Into<alloc::string::String>) -> Self
+pub const fn radroots_transport::SinkStatus::transport_id(&self) -> radroots_transport::TransportId
+pub struct radroots_transport::SourceStatus
+impl radroots_transport::SourceStatus
+pub const fn radroots_transport::SourceStatus::availability(&self) -> radroots_transport::capability::Availability
+pub const fn radroots_transport::SourceStatus::capabilities(&self) -> radroots_transport::capability::SourceCapabilities
+pub fn radroots_transport::SourceStatus::from_descriptor(&radroots_protocol::capability::v1::TransportDescriptor, bool, impl core::convert::Into<alloc::string::String>) -> Self
+pub const fn radroots_transport::SourceStatus::is_configured(&self) -> bool
+pub const fn radroots_transport::SourceStatus::maturity(&self) -> radroots_transport::capability::Maturity
+pub fn radroots_transport::SourceStatus::message(&self) -> &str
+pub fn radroots_transport::SourceStatus::new(radroots_transport::TransportId, bool, radroots_transport::capability::Maturity, radroots_transport::capability::Availability, radroots_transport::capability::SourceCapabilities, impl core::convert::Into<alloc::string::String>) -> Self
+pub const fn radroots_transport::SourceStatus::transport_id(&self) -> radroots_transport::TransportId
+pub struct radroots_transport::Target
+impl radroots_transport::target::Target
+pub fn radroots_transport::target::Target::fingerprint(&self) -> &radroots_transport::target::TargetFingerprint
+pub fn radroots_transport::target::Target::kind(&self) -> &RadrootsTransportKind
+pub fn radroots_transport::target::Target::label(&self) -> core::option::Option<&radroots_transport::target::TargetLabel>
+pub fn radroots_transport::target::Target::local(impl core::convert::AsRef<str>) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+pub fn radroots_transport::target::Target::local_with_metadata(impl core::convert::AsRef<str>, core::option::Option<radroots_transport::target::TargetScope>, core::option::Option<radroots_transport::target::TargetLabel>) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+pub fn radroots_transport::target::Target::new(RadrootsTransportKind, impl core::convert::AsRef<str>) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+pub fn radroots_transport::target::Target::new_with_metadata(RadrootsTransportKind, impl core::convert::AsRef<str>, core::option::Option<radroots_transport::target::TargetScope>, core::option::Option<radroots_transport::target::TargetLabel>) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+pub fn radroots_transport::target::Target::nostr_relay(impl core::convert::AsRef<str>) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+pub fn radroots_transport::target::Target::nostr_relay_with_metadata(impl core::convert::AsRef<str>, core::option::Option<radroots_transport::target::TargetScope>, core::option::Option<radroots_transport::target::TargetLabel>) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+pub fn radroots_transport::target::Target::reticulum() -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+pub fn radroots_transport::target::Target::reticulum_with_metadata(impl core::convert::AsRef<str>, core::option::Option<radroots_transport::target::TargetScope>, core::option::Option<radroots_transport::target::TargetLabel>) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+pub fn radroots_transport::target::Target::scope(&self) -> core::option::Option<&radroots_transport::target::TargetScope>
+pub fn radroots_transport::target::Target::uri(&self) -> &radroots_transport::target::EndpointUri
+impl<'de> serde_core::de::Deserialize<'de> for radroots_transport::target::Target
+pub fn radroots_transport::target::Target::deserialize<D>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> where D: serde_core::de::Deserializer<'de>
+pub struct radroots_transport::TargetSet
+impl radroots_transport::target::TargetSet
+pub fn radroots_transport::target::TargetSet::is_empty(&self) -> bool
+pub fn radroots_transport::target::TargetSet::len(&self) -> usize
+pub fn radroots_transport::target::TargetSet::new(alloc::vec::Vec<radroots_transport::target::Target>) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+pub fn radroots_transport::target::TargetSet::targets(&self) -> &[radroots_transport::target::Target]
+impl<'de> serde_core::de::Deserialize<'de> for radroots_transport::target::TargetSet
+pub fn radroots_transport::target::TargetSet::deserialize<D>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> where D: serde_core::de::Deserializer<'de>
+pub struct radroots_transport::TransportId(_)
+impl radroots_transport::TransportId
+pub const radroots_transport::TransportId::LOCAL: Self
+pub const radroots_transport::TransportId::Local: Self
+pub const radroots_transport::TransportId::NOSTR: Self
+pub const radroots_transport::TransportId::Nostr: Self
+pub const radroots_transport::TransportId::RADROOTSD: Self
+pub const radroots_transport::TransportId::RETICULUM: Self
+pub const radroots_transport::TransportId::Reticulum: Self
+pub fn radroots_transport::TransportId::as_str(&self) -> &str
+pub fn radroots_transport::TransportId::canonical_label(&self) -> alloc::string::String
+pub fn radroots_transport::TransportId::parse(impl core::convert::AsRef<str>) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+pub fn radroots_transport::TransportId::parse_canonical(impl core::convert::AsRef<str>) -> core::result::Result<Self, radroots_transport::error::RadrootsTransportError>
+impl core::convert::AsRef<str> for radroots_transport::TransportId
+pub fn radroots_transport::TransportId::as_ref(&self) -> &str
+impl core::convert::From<radroots_protocol::capability::v1::TransportKind> for radroots_transport::TransportId
+pub fn radroots_transport::TransportId::from(radroots_protocol::capability::v1::TransportKind) -> Self
+impl core::convert::From<radroots_transport::TransportId> for radroots_protocol::capability::v1::TransportKind
+pub fn radroots_protocol::capability::v1::TransportKind::from(radroots_transport::TransportId) -> Self
+impl core::convert::TryFrom<&str> for radroots_transport::TransportId
+pub type radroots_transport::TransportId::Error = radroots_transport::error::RadrootsTransportError
+pub fn radroots_transport::TransportId::try_from(&str) -> core::result::Result<Self, Self::Error>
+impl core::convert::TryFrom<alloc::string::String> for radroots_transport::TransportId
+pub type radroots_transport::TransportId::Error = radroots_transport::error::RadrootsTransportError
+pub fn radroots_transport::TransportId::try_from(alloc::string::String) -> core::result::Result<Self, Self::Error>
+impl core::fmt::Display for radroots_transport::TransportId
+pub fn radroots_transport::TransportId::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl core::str::traits::FromStr for radroots_transport::TransportId
+pub type radroots_transport::TransportId::Err = radroots_transport::error::RadrootsTransportError
+pub fn radroots_transport::TransportId::from_str(&str) -> core::result::Result<Self, Self::Err>
+impl serde_core::ser::Serialize for radroots_transport::TransportId
+pub fn radroots_transport::TransportId::serialize<S>(&self, S) -> core::result::Result<<S as serde_core::ser::Serializer>::Ok, <S as serde_core::ser::Serializer>::Error> where S: serde_core::ser::Serializer
+impl<'de> serde_core::de::Deserialize<'de> for radroots_transport::TransportId
+pub fn radroots_transport::TransportId::deserialize<D>(D) -> core::result::Result<Self, <D as serde_core::de::Deserializer>::Error> where D: serde_core::de::Deserializer<'de>
+pub const radroots_transport::RADROOTS_TRANSPORT_DELIVERY_REQUEST_ID_MAX_BYTES: usize
+pub const radroots_transport::TARGET_SET_MAX_ITEMS: usize
+pub const radroots_transport::TRANSPORT_ID_MAX_BYTES: usize
+pub trait radroots_transport::EventSink: core::marker::Send + core::marker::Sync
+pub fn radroots_transport::EventSink::deliver(&self, radroots_transport::sink::DeliveryRequest) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_transport::sink::DeliveryReceipt, radroots_transport::error::Error>>
+pub fn radroots_transport::EventSink::status(&self) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_transport::SinkStatus, radroots_transport::error::Error>>
+pub trait radroots_transport::EventSource: core::marker::Send + core::marker::Sync
+pub fn radroots_transport::EventSource::fetch(&self, radroots_transport::source::FetchRequest) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_transport::source::FetchPage, radroots_transport::error::Error>>
+pub fn radroots_transport::EventSource::status(&self) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_transport::SourceStatus, radroots_transport::error::Error>>
+pub type radroots_transport::BoxFuture<'a, T> = core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = T> + core::marker::Send + 'a)>>
+pub type radroots_transport::Error = radroots_transport::error::RadrootsTransportError
+pub type radroots_transport::RadrootsTransportFuture<'a, T> = core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = core::result::Result<T, radroots_transport::error::RadrootsTransportError>> + core::marker::Send + 'a)>>